Universidad

Tecnológica
de México
Campus Cuitláhuac
Campus en Línea
Ingeniería en
Software y Redes

Estructura de Datos
Entregable 2
Listas, Pilas y Colas

Alumno. Manuel Alejandro Carreón Huitrón

No. de Cuenta: 17924019
Profesor: Claudia Ivette Cruz Valenzuela

28 de noviembre de 2018
Ejercicio 1.

Del siguiente programa:

//Ejemplo de PILA

#include <iostream.h>
#include <conio.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>

struct pilas
{
int d;
pilas *a;
}*c,*e;

void menu(void);
void ingresar(void);
void sacar (void);
void actualizar_pila(void);

main()
{
menu();
}
void menu(void)
{
int y,opc;
for(;;)
{
cout<<"\n1. Ingresar datos";
cout<<"\t2. Sacar datos";
cout<<"\t0. Terminar";
cout<<"\n Ingrese opcion: ";cin>>opc;
switch(opc)
{
case 1:
ingresar();
break;
case 2: sacar();
break;
case 0: exit(1);
default: cout<<"\n Opcion no valida!!"; break;
}
actualizar_pila();
cout<<"\n\nOprima una tecla para continuar";
getch();
}
}
void ingresar (void)
{
if(!c)
{
c=new(pilas);
cout<<"Ingrese elemento: ";
cin>>c->d;
c->a=NULL;
return;
}
e=new(pilas);
cout<<"\nIngrese elemento: ";
cin>>e->d;
e->a=c;
c=e;
}
void sacar(void)
{
if(!c)
{
cout<<"\n\nNo hay elementos!!";
return;
}
e=new(pilas);
e=c;
cout<<"\n\nElemento eliminado: " <<e->d;
c=e->a;
delete(e);
}
void actualizar_pila(void)
{
int y=2,i,ca=0;
e=c;
while(e)
{
ca++;
e=e->a;
}
for(i=0;i<=ca;i++)
{
cout<<" ";
}
//muestro lo que tiene la pila!!
i=0;
e=c;
while(e)
{
cout<<"\n";
cout<<++i<<" - "<<e->d;
e=e->a;
}
}

a) ¿Cuál es la salida que produce?

b) Hacer el análisis del programa, es decir explicando el funcionamiento de la ‘PILA’

En el caso de este ejercicio se realiza mediante una estructura de datos de forma Pila,
mediante la cual, con forme se van agregando los datos, el ultimo en ser agregado es el que
queda en la parte superior de la pila, motivo por el cual al momento de eliminar alguno de
ellos, el último elemento en ser agregar será el primero en desaparecer, tal como lo muestra
la captura de pantalla de las salidas que produce el programa.

Al seleccionar la opción 1, nos aparecerá un nuevo mensaje, el cual nos indica que
ingresemos el elemento deseado, posterior mente nos actualizara la pila que hemos ido
elaborando, dejando en la parte superior el ultimo elemento ingresado.

Si elegimos la opción 2 “Sacar datos”, el programa de manera automática eliminará el

elemento que se encuentra en la parte superior de la pila y nos lo indicará con el mensaje
de “Elemento eliminado:”, y una vez mas nos mostrará la pila actualizada.
Tal como se muestra en la imagen a continuación.

(Luis, 2018)

Ejercicio 2.

Del siguiente programa:

//Ejemplo Listas
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <iostream.h>

struct dato {
int i;
dato *s;
}*a, *i, *p, *e;
int da;
int buscar(int d);
void insertar(int dat);
void mostrar(void);
void borrar(void);
void menu(void);

main()
{
menu();
}
void menu(void)
{
int opc,da;
do
{
cout<<"\t1 - Buscar datos \n";
cout<<"\t2 - Insertar datos \n";
cout<<"\t3 - Mostrar todos los datos \n";
cout<<"\t4 - Borrar un dato \n";
cout<<"\t0 - Finalizar \n";
cout<<"\nSeleccione opcion: \n";
cin>>opc;
switch(opc)
{
case 0: cout<<"\n\nFinaliza el programa";
getch();
//Usar delete para eliminar
//toda la lista
p=i;
while(p)
{
a=p;
p=p->s;
delete(a);
}
exit(0);
case 1: cout<<"\n\nIngrese dato a buscar: ";
cin>>da;
if(buscar(da))
cout<<"\n\n Dato existe";
else
cout<<"\n\n Dato NO EXISTE";
getch();
break;
case 2: cout<<"Ingrese dato: ";
cin>>da;
insertar(da);
break;
case 3: mostrar();
break;
case 4: borrar();
break;
//Valida que el dato sea válido
default: cout<<"\n\nOPCION NO VALIDA!!!";
getch();
}
}while(opc);
}
void mostrar(void)
{
int cont=1;
if(!i)
{
cout<<"\n\nNO HAY LISTA PARA MOSTRAR\n";
getch();
return;
}
p=i;
cout<<endl<<endl;
while(p)
{
cout<<cont++<<" - Valor = "<<p->i<<endl;
p=p->s;
}
cout<<"\n\n Termina";
getch();
}
int buscar(int d)
{
if (!i)
{
cout<<"No hay datos en la lista!!!";
getch();
return(0);
}
p=i;
a=NULL;
while(p->s && p->i<d)
{
a=p;
p=p->s;
}
return(p->i==d?1:0);
}
void insertar(int dat)
{
if(!i)
{
i=new(dato);
i->s=NULL;
i->i=dat;
return;
}
if(buscar(dat))
{
cout<<"\n\nDato existente";
getch();
return;
}
e=new(dato);
e->i=dat;
if(p==i && p->s)
{
e->s=p;
i=e;
return;
}
if(p==i && !p->s)
{
if(p->i < e->i)
{
p->s=e;
e->s=NULL;
}
else
{
e->s=p;
i=e;
}
return;
}
if(p->s)
{
a->s=e;
e->s=p;
return;
}
if(e->i > p->i)
{
e->s=NULL;
p->s=e;
}
else
{
a->s=e;
e->s=p;
}
}
void borrar(void)
{
cout<<"\n\nIngrese dato a eliminar: ";
cin>>da;
if(buscar(da))
{
if(a)
a->s=p->s;
else
i=p->s;
delete(p);
cout<<"\n\nDato eliminado";
}
else
cout<<"\n\nDato no se encuentra";
getch();
}

a) ¿Cuál es la salida que produce?

b) Hacer el análisis del programa, es decir explicando el funcionamiento de la ‘LISTA’

Este segundo ejercicio se realiza mediante una estructura de datos de forma Lista, mediante
la cual, con forme se van agregando los datos se van generando nodos en la lista, a diferencia
del ejercicio anterior en este caso al seleccionar eliminar elemento podemos eliminar
cualquiera de los nodos generados anteriormente, además podemos elegir la opción de
buscar dato, si el nodo ha sido creado aparecerá el mensaje “dato existe”, de la misma
manera si el nodo no ha sido creado o ha sido eliminado no aparecerá el mensaje “dato no
EXISTE”. Al elegir la opción mostrar todos los datos, nos aparecerán en el orden en el que
fueron creados.
Ejercicio 3.

Del siguiente programa:

//Ejemplo Cola
#include <iostream.h>
#include <conio.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
struct datos {
int dato;
datos *s;
}*p,*aux,*u;
void insertar (int dat);
void borrar ();
void listar ();
main()
{
int opc,y;
do
{
cout<<"\t1. Insertar \n";
cout<<"\t2. Borrar \n";
cout<<"\t3. Listar \n";
cout<<"\t4. Salir \n";
cout<<"\n Ingrese opcion: \n";cin>>opc;
switch(opc)
{
case 1: cout<<"Ingrese dato: ";
cin>>y;
insertar(y);
cout<<"\nDato insertado!!";
break;
case 2: borrar();
break;
case 3: listar(); break;
case 4: exit(1);
default: cout<<"\n Opcion no valida!!"; break;
}
}while(opc);
}
void insertar (int dat)
{
aux=new(datos);
aux->dato=dat;
if(u)
{
u->s=aux;
aux->s=NULL;
u=aux;
}
else
{
p=u=aux;
}
}
void borrar()
{
if(p)
{
aux=p;
cout<<"\nElimino a " <<p->dato;
p=aux->s;
delete(aux);
}
else
{
cout<<"\n No hay datos";
}
}
void listar()
{
int i;
if(!u)
{
cout<<"\n No hay datos en la cola";
return;
}
aux=p;
while(aux)
{
cout<<"\n"<<++i<<" - "<<aux->dato;
aux=aux->s;
}
}
a) ¿Cuál es la salida que produce?

b) Hacer el análisis del programa, es decir explicando el funcionamiento de la ‘COLA’

En el caso de este ejercicio se realiza mediante una estructura de datos de forma Cola,
mediante la cual, con forme se van agregando los datos, mismos que quedan ordenados tal
como se fueron ingresando, a diferencia del primer ejercicio (Pila) al momento de eliminar
alguno de ellos, es el primer elemento en ser agregar el que será el primero en desaparecer,
tal como lo muestra la captura de pantalla de las salidas que produce el programa.
Al seleccionar la opción 1 nos solicita que ingresemos el dato, una vez realizado esto con
diferentes datos podemos utilizar la opción 3 que es “Listar”, en esta nos aparecerá la lista
de acuerdo al orden en el que ingresamos los datos, si deseamos eliminar algún elemento y
elegimos la opción 2 “Borrar”; en automático el programa eliminará el primer dato
ingresado.

(Garo, 2011)

Ejercicio 4

A partir de la ejecución de los programas de los ejercicios 1, 2,3 y el aprendizaje adquirido,

realizar un cuadro comparativo de las estructuras de datos: Lista, pila y cola.
Estructura de
Lista Pila Cola
Datos

“Es una de las

estructuras de datos
Una cola es una
fundamentales, y Una pila es una
colección de
puede ser usada para colección de objetos
objetos de primero
implementar otras Last In First Out
en entrar, primero
estructuras de (LIFO).
en salir (FIFO).
datos”. (Valenzuela,
Carácterísticas 2018)

“Una lista enlazada Se utiliza una pila La cola se utiliza

es un tipo de dato cuando necesita el cuando se necesita
auto-referenciado último ingreso, el acceso por primera
por que contienen un primer acceso a los vez, primero en
puntero o link a otro objetos. salir, a los objetos.
dato del mismo
tipo”. (Valenzuela,
2018)

“Consiste en una
secuencia de nodos,
en los que se
guardan campos de Una pila consiste Una cola consiste
datos arbitrarios y básicamente en dos básicamente en
una o dos operaciones, Push y dos operaciones En
referencias(punteros) Pop. cola y En cola.
al nodo anterior o
posterior”.
(Valenzuela, 2018)

“Permiten
inserciones y
eliminación de nodos
en cualquier punto
Cuando inserta un Cuando inserta un
de la lista en tiempo
elemento en la pila, elemento en una
constante
se le llama empujar el Cola, se llama
(suponiendo que
elemento y cuando Encolar y cuando
dicho punto está
extrae el elemento de extrae un elemento
previamente
la pila, se llama hacer de la Cola, se llama
identificado o
estallar el elemento. En cola.
localizado), pero no
permiten un acceso
aleatorio”.
(Valenzuela, 2018)

“Los elementos
enlazados pueden
ser diferentes al La operación de
orden de puesta en cola se
almacenamiento en Tanto Push como Pop realiza al final de la
la memoria o el se realizan en la parte cola y la operación
disco, permitiendo superior de la pila. de salida de cola se
que el orden de realiza al final de la
recorrido de la lista cola.
sea diferente al de
almacenamiento”.
(Valenzuela, 2018)
Conclusión

Después de haber analizado los diferentes tipos de estructuras de datos me he dado cuenta
de que cada una de ellas puede ser útil para casos muy específicos, en el caso de las Pilas
son muy útiles en los casos de asignación de memoria para un hardware; en el caso de las
Colas, son muy útiles en casos donde los datos se almacenan para su posterior
procesamiento; por último, las listas, que es a mi parecer el método con más utilidades
debido a su flexibilidad pueden ser utilizadas para elaborar cronogramas, realizar
transacciones bancarias o inclusive para controlar una lista de reproducción de música.

Referencias

calcifer.org. (2018). www.calcifer.org. Obtenido de

http://www.calcifer.org/documentos/librognome/glib-lists-queues.html
Luis, U. N. (2018). www0.unsl.edu.ar. Obtenido de
http://www0.unsl.edu.ar/~pmp/archivos/teoria5_bol2.pdf
Point, T. (2018). www.tutorialspoint.com. Obtenido de
https://www.tutorialspoint.com/data_structures_algorithms/linked_list_algorithms.
htm
Red, E. (2018). www.ecured.cu. Obtenido de
https://www.ecured.cu/Cola_(Estructura_de_datos)
Valenzuela, C. I. (2018). uniteconline.blackboard.com. Obtenido de
https://uniteconline.blackboard.com/bbcswebdav/pid-3314637-dt-content-rid-
81406301_1/courses/UNI_191_03_24_B3_ING_SRL6L_TOL515/Estructura%20de%20
Datos%20Semana%202%20Tema%206%20Listas.pdf