Práctica 4.

Pilas y colas Dinámicas

Profesor Facilitador: Dra. Areli Rojo Hernández
Alumno: Diego Reyes Blancas - 2213026667
Alumno: Alan David Benitez Garcia - 2193036354
Programa 1: Pila dinámica
1. El programa uno cuenta con una bienvenida para el usuario haciendo uso del siguiente código.
void bienvenida(){
printf("\n=== Bienvenido a la practica 4. Pilas y Colas Dinamicas. === ");
printf("\n=== Ejercicio 1 === ");
printf("\n=== Nombre del Alumno 1: Alan David Benitez Garcia === ");
printf("\n=== Matricula del Alumno 1: 2193036354 === ");
printf("\n=== Nombre del Alumno 2: Diego Reyes Blancas === ");
printf("\n=== Matricula del Alumno 2: 2213026667 === ");
printf("\n=== Nombre de la UEA: Estructuras de datos lineales === ");
printf("\n=== Nombre del profesor: Dra. Areli Rojo Hernandez === ");
printf("\n=== Universidad Autonoma Metropolitana === \n\n");
system("pause");
}
como resultado en consola nos muestra la siguiente bienvenida para el usuario. imagen 1.1

imagen 1.1

2. El programa solicita al usuario números en un rango (1,50) y hace la validación correspondiente

mientras el usuario no introduzca un “0” este podrá seguir introduciendo valores (imagen 1.2)

void EJ_1(Pila *a, Pila *b, Pila *c){

int entrada;
printf("\n Bienvenid@ al ejercicio 1 \n");
do{
printf("\n Introduzca un valor para la pila (rango 1 - 50) (pulsa 0 para
terminar de ingresar datos): ");
scanf("%d", &entrada);

if (entrada >= 1 && entrada <= 50)

{
push(a, crear_Nodo(crear_dato(entrada)));
}
else
{
printf("\n El valor esta fuera del rango, no se ha podido añadir a la
pila :c \n");
 }
} while (entrada !=0);

printf("\n Datos almacenados en la Pila. \n ");

system("pause");

imagen 1.2

una vez el usuario termine de introducir números a la pila el programa imprime automáticamente el
contenido de la pila (imagen 1.3)

printf("\n======================================\n ");
printf("Primera impresion de la pila principal:");
printf("\n======================================\n ");
imprimir(a);
system("pause");

imagen 1.3

3. el programa desapila el contenido uno a la vez, si el contenido de la pila es par lo agrega la pila (b)
de lo contrario lo agrega a la pila (c)
while (a->cima != 0){
int x = ipop(a);
if (x%2 == 0){
push(b,crear_Nodo(crear_dato(x)));
}
else{
push(c,crear_Nodo(crear_dato(x)));
}
}
4. Por último el programa imprime la pila original, la par y la impar (imagen 1.4).
y libera la memoria solicitada.

printf("\n======================================\n ");
printf("Pila de valores pares");
printf("\n======================================\n ");
imprimir(b);

printf("\n======================================\n ");
printf("Pila de valores impares");
printf("\n======================================\n ");
imprimir(c);

printf("\n======================================\n ");
printf("Segunda impresion de la pila principal");
printf("\n======================================\n ");
imprimir(a);
vaciarPila(b);
vaciarPila(a);
vaciarPila(c);
free(a);
free(b);
free(c);
system("pause");

imagen 1.4
programa 2: cola dinámica
1. el programa solicita al usuario 10 números en un rango del (1,1000) y hace la comprobación
correspondiente (imagen 2.1)
Una vez comprobados los valores el programa los almacena en una cola dinámica (a).
printf("\n Bienvenid@ al ejercicio 2 \n");
do{
printf("\n Introduzca 10 valores para la cola (rango 1 - 1000): ");
scanf("%d", &entrada);

if (entrada >= 1 && entrada <= 1000)

{
insertar_cola(a, crear_Nodo(crear_UAMITO(entrada)));
limite++;
}
else
{
printf("\n El valor esta fuera del rango, no se ha podido añadir a la
cola :c \n");
}
} while (limite != 10);

imagen 2.1
2. el programa imprime la cola introducida por el usuario. (imagen 2.2)

printf("\n===========================\n");
printf("Se imprime cola actual con los valores dados por el usuario ");
printf("\n===========================\n");
printCola(a);
system("pause");

(imagen 2.2)

3. mientras que la cola no esté vacía, el programa busca el contenido de la cola con menor valor
y lo almacena en aux.
Una vez encontrado este valor se hace un recorrido de la cola, desencolando y encolando nodos de
tal forma que el nodo con contenido de menor valor, quede en la cabeza de la cola (a).
Posteriormente quita la cabeza de la cola (a) y la inserta en la cola (b).
while (isEmpty(*a)!=1)
{
aux = crear_Nodo(crear_UAMITO(1000));
aux2 = a->primero;
for ( i = 0; i < count; i++)
{
if (aux2->datos->id <= aux->datos->id)
{
aux->datos->id = aux2->datos->id;
}
aux2 = aux2->sig;
}
 while (a->primero->datos->id != aux->datos->id) //aux tiene al mas pequeño
{
aux3 = quitar_cabeza2(a);
insertar_cola(a, aux3);
aux3=NULL;
free(aux3);
}
aux3 = quitar_cabeza2(a);
insertar_cola(b, aux3);
aux3=NULL;
free(aux3);
count--;
}
4. Como resultado del punto 3 (programa 2) la cola principal (a) debe haber quedado vacía y la cola
secundaria (b) debe haber quedado ordenada de menor a mayor. (imagen 2.3)

imagen 2.3
Conclusiones:
Alan David Benitez Garcia
El uso de una lista, una cola y una pila va estrechamente ligada, se puede concluir que son bastante similares
en cuanto a estructura, desarrollo y uso. La diferencia que radica en estas es la versatilidad a la hora de
emplearse para resolver alguna problemática, pues la implementación de alguna de estas tres opciones
puede ser mejor para resolver alguna problemática en particular.
Aunque en apariencia la lista, la cola y la pila son muy similares, tienen características que les hacen óptimos
en algunas problemáticas particulares, como consecuencia se tiene una variedad de opciones para resolver
los problemas que se nos presenten en los cuales se requiera implementar algún tipo de lista.
El dominio de este tema implica una facilidad a la hora de escribir códigos pues podemos obtener soluciones
óptimas y más sencillas de entender al usuario, además podemos ahorrar memoria, líneas de código y con
una buena implementación del código adecuado para la ocasión podemos evitar problemas a futuro.
Se puede concluir que, con todos los resultados obtenidos, prácticamente eligiendo una lista, cola o pila sin
importar el orden podemos resolver un mismo problema, la diferencia radica en las reglas de
implementación que tiene cada una de ellas. Siendo así todo se puede realizar con una lista implementado
los procedimiento o funciones adecuadas, y es la manera más sencilla.
Diego Reyes Blancas.
A lo largo de la práctica utilizamos las listas (simples y circulares) para implementar una pila y una cola
dinámica respectivamente, observamos la diferencia de las reglas al momento de manipular estas mismas,
en el caso de la cola teniendo que desencolar y encolar datos (de esta forma notamos que es menos
probable perder la información) y en el caso de la pila haciendo uso de los pop, push.
El uso de las de pilas y colas es muy similar ya que se puede resolver prácticamente los mismos problemas la
diferencia se encuentra en la forma que el programador decida optimizar su uso; En programas pequeños
probablemente no se note la diferencia, pero en programas grandes o con cierto tipo de información sería
útil utilizar algún tipo de lista en particular, y ahí se tendrían que medir los tiempos de ejecución para que sea
realmente observable el cambio.