ESCUELA SUPERIOR POLITÉCNICA AGROPECUARIA

DE MANABÍ MANUEL FÉLIX LÓPEZ

CARRERA DE COMPUTACIÓN

SEMESTRE: TERCERO PERÍODO: MAR. 2017 /SEP. 2017

ESTRUCTURA DE DATOS

TEMA:

GESTION DINAMICA (PILAS, COLAS Y LISTAS)

AUTOR:
MARIO G. VALLEJO REINOSO

FACILITADOR:

ING. JAVIER H. LÓPEZ ZAMBRANO

CALCETA, JULIO 2017

 2

ÍNDICE
ÍNDICE .......................................................................................................................................... 2
I. INTRODUCCION ............................................................................................................................. 3

II. MARCO TEORICO ........................................................................................................................... 4

2.1. DECLARACION DE UN NODO ....................................................................................................... 4

2.1.1. EL APUNTADOR NULO ........................................................................................................ 5
2.2. PILAS ........................................................................................................................................... 6
2.2.1. CARACTERISTICAS DE LAS PILAS ......................................................................................... 6
2.2.2. OPERACIONES UTILIZADAS EN UNA PILA ........................................................................... 7
2.2.3. METODOS PUSH Y POP ....................................................................................................... 7
2.3. COLAS .......................................................................................................................................... 8
2.3.1. COLAS SIMPLES ................................................................................................................... 8
2.3.2. COLAS CIRCULARES............................................................................................................. 9
2.3.3. COLAS CON PRIORIDAD .................................................................................................... 10
2.3.4. COLAS DE DOBLE ENTRADA .............................................................................................. 10
2.3.5. CARACTERISTICAS DE LAS COLAS ..................................................................................... 11
2.3.6. OPERACIONES UTILIZADAS POR COLAS ............................................................................ 12
2.3.7. METODOS PUSH Y POP ..................................................................................................... 12
2.4. LISTAS ........................................................................................................................................ 13
2.4.1. ESTRUCTRURA DE UNA LISTA ........................................................................................... 13
2.4.2. LISTAS ENLAZADAS ........................................................................................................... 14
2.4.3. CLASIFICACION DE LAS LISTAS ENLAZADAS ...................................................................... 14
2.4.4. OPERACIONES CON LAS LISTAS ENLAZADAS .................................................................... 16
2.4.5. ACCESO A UNA LISTA ........................................................................................................ 16
2.4.6. INSERCION DE UN ELEMENTO EN UNA LISTA .................................................................. 16
2.4.7. INSERCION DE UN NODO AL FINAL DE UNA LISTA ........................................................... 17
2.4.8. BORRADO DE UN NODO EN UNA LISTA............................................................................ 17

III. ANÁLISIS DE RESULTADOS ........................................................................................................... 18

3.1. EJERCICIO DE PILAS .......................................................................................................................... 18

3.2. EJERCICIO DE COLAS ........................................................................................................................ 21
3.3. EJERCICIO DE LISTA .......................................................................................................................... 24

IV. CONCLUSIONES ....................................................................................................................... 29

BIBLIOGRAFÍA ...................................................................................................................................... 30
 3

I. INTRODUCCION

Las estructuras dinámicas nos permiten crear estructuras de datos que se

adopten a las necesidades reales a las que suelen enfrentarse nuestros
programas. Las estructuras de datos están compuestas de otras pequeñas
estructuras a las que llamaremos nodos o elementos, que agrupan los datos
con los que trabajara nuestro programa y además uno o más punteros
autorreferenciales, es decir, punteros a objetos del mismo tipo.

Según Joyanes L. (2008). La memoria dinámica es un espacio de

almacenamiento que se puede solicitar en tiempo de ejecución. Además de
solicitar espacios de almacenamiento, también podemos liberarlos (en tiempo
de ejecución) cuando dejemos de necesitarlos. Para realizar esta
administración de la memoria dinámica, C++ cuenta con dos
operadores new y delete. Antes de utilizarlos, debemos incluir el encabezado
<new>.El operador new reserva memoria dinámica de cualquier tipo, esto son
tipos primitivos (int, double, etc) o tipos definidos por el usuario (clases o
estructuras).

C++, ofrece la posibilidad de crear o destruir variables en tiempo de ejecución

del programa, a medida que van siendo necesitadas durante la ejecución del
mismo. Puesto que estas variables no son declaradas en el programa, no
tienen nombre y se denominan variables anónimas. Si un lenguaje permite la
creación de variables anónimas, debe también proporcionar una forma de
referirse a estas variables, de modo que se les pueda asignar valores, del
mismo modo, debe proporcionar una forma de acceder a estas. Para ello c++
proporciona el tipo Puntero (Rodriguez L , 2012).

Todas las estructuras de datos vistas hasta ahora son estáticas, esto es, no
puede cambiar su tamaño durante la ejecución del programa. Cuando las
estructuras de datos cambian su tamaño durante la ejecución del programa se
utilizan las estructuras dinámicas de datos. Ciertas estructuras de datos como
pilas, colas y listas se utilizan la memoria dinámica.
 4

II. MARCO TEORICO

2.1. DECLARACION DE UN NODO

Según Joyanes L y Zanohero I (2009). Cada nodo de una lista enlazada
combina dos partes: un tipo de dato (entero, real, doble, carácter o tipo
Predefinido) y un enlace (puntero) al siguiente nodo. En C se puede declarar un
nuevo tipo de dato, Correspondiente a un nodo, mediante la especificación de
struct que agrupa las dos partes citadas.

La declaración utiliza el tipo struct que permite agrupar campos de diferentes

tipos, el campodato y el campo enlace. Con typedef se puede declarar a la vez
un nuevo identificador de struct Nodo; en el caso anterior se ha elegido nodo.
Dado que los tipos de datos que se puede incluir en una lista pueden ser de
cualquier tipo (enteros, dobles, caracteres o incluso cadenas), con el objeto de
que el tipo de dato de cada nodo se pueda cambiar con facilidad se suele
utilizar la sentencia typedef para declarar el nombre de elemento como un
sinónimo del tipo de dato de cada campo. A continuación se muestra la
declaración:

Entonces, si se necesita cambiar el tipo de elemento en los nodos, sólo se

tendrá que cambiar la sentencia de declaración de tipos que afecta a elemento.
Siempre que una función necesite referirse al tipo de dato del nodo, puede
utilizar el nombre elemento.
 5

2.1.1. EL APUNTADOR NULO

La palabra NULL representa el apuntador nulo, que es una constante especial

de C. Se puede utilizar el apuntador nulo para cualquier valor de apuntador que
no apunte a ningún sitio. El apuntador nulo se utiliza, normalmente, en dos
situaciones:
 Usar el apuntador nulo en el campo enlace o siguiente del nodo final de
una lista enlazada.
 Cuando una lista enlazada no tiene ningún nodo, se utiliza el apuntador
NULL como apuntador de cabeza y de cola. Tal lista se denomina lista
vacía.
El apuntador de cabeza y de cola en una lista enlazada puede ser NULL, lo que
indicará que la lista está vacía (no tiene nodos). Éste suele ser un método
usual para construir una lista. Cualquier función que se escribe para manipular
listas enlazadas debe poder manejar un apuntador de cabeza y un apuntador
de cola nulos.
En un programa, el apuntador nulo se puede escribir como NULL, que es una
constante de la biblioteca estándar stdlib.h.El apuntador nulo se puede asignar
a una variable apuntador con una sentencia de asignación ordinaria. (Joyanes
L y Zanohero I 2009).

Figura 1 Lista enlazada con apuntador null (Joyanes L y Zanohero I 2009).

 6

2.2. PILAS

Según Joyanes L. (2008). La pila es una estructura lineal de datos compuesta

por una secuencia de elementos en la que las operaciones sólo se pueden
realizar por uno de sus extremos llamado cima (tope o top), con numerosas
analogías en la vida real: una pila de platos, una pila de monedas, una pila de
cajas de zapatos, una pila de camisas, una pila de bandejas, etc.

Dado que las operaciones de insertar y eliminar se realizan por un solo extremo
(el superior), los elementos solo pueden eliminarse en orden inverso al que se
insertan en la pila. El último elemento que se pone en la pila es el primero que
se puede sacar; por ello, a estas estructuras se les conoce como LIFO (last-in,
first-out).

2.2.1. CARACTERISTICAS DE LAS PILAS

Se característica fundamental es que al extraer se obtiene siempre el último

elemento que acaba de insertarse. Por esta razón también se conocen como
estructuras de datos LIFO (del inglés Last In First Out). (Joyanes L y Zanohero
I 2009).

Una pila generalmente se representa gráficamente de forma vertical, sin

embargo, el TOPE en la estructura es una señal para orientar su
funcionamiento:

Figura 2. Representación gráfica de una pila (Herrera C, 2015).

 7

2.2.2. OPERACIONES UTILIZADAS EN UNA PILA

 Crear: Pila Inicia

 Insertar (push): Pone un dato en la pila
 Quitar (pop):Retira (saca) un dato de la pila
 Pila vacía: Comprueba si la pila no tiene elementos
 Pila llena: Comprueba si la pila está llena de elementos
 Limpiar pila: Quita todos sus elementos y deja la pila vacía
 Cima: Obtiene el elemento cima de la pila
 Tamaño de la pila: Número de elementos máximo que puede
contener la pila (Joyanes L y Zanohero I 2009).

2.2.3. METODOS PUSH Y POP

Una pila (stack) es una colección ordenada de elementos a los que sólo se
puede acceder por un único lugar o extremo. Los elementos de la pila se
añaden o quitan sólo por su parte superior, la cima de la pila. Las pilas son
estructura de datos LIFO (last-in, first-out/último en entrar, primero en salir). La
operación insertar (push) sitúa un elemento en la cima de la pila y quitar (pop)
elimina o extrae el elemento cima de la pila.(Joyanes L y Zanohero I 2009).

Figura 3. Método push con números enteros (Herrera C, 2015)

Figura 4. Método pop (Herrera C, 2015)

 8

2.3. COLAS
Una cola es una estructura de datos cuyos elementos mantienen un orden tal
que sólo se pueden añadir elementos por un extremo, final de la cola, y
eliminar o extraer por el otro extremo, llamado frente. Los elementos se
insertan por el extremo final, y se suprimen por el otro extremo, llamado
frente(Joyanes L y Zanohero I 2009).

Figura 5. Implementación de una cola con punteros (Sáez X, 2010)

Un elemento se inserta en la cola (parte final) de la lista y se suprime o elimina

por la frente (parte inicial, frente) de la lista. Las aplicaciones utilizan una cola
para almacenar elementos en su orden de aparición o concurrencia (Deitel P y
Deitel H 2008).

Figura 6. Representación gráfica de una cola (Deitel P y Deitel H 2008).

2.3.1. COLAS SIMPLES

Se inserta por un sitio y se saca por otro, en el caso de la cola simple se inserta
por el final y se saca por el principio. Para gestionar este tipo de cola hay que
recordar siempre cual es el siguiente elemento que se va a leer y cuál es el
último elemento que se ha introducido. (Joyanes L y Zanohero I 2009).
 9

2.3.2. COLAS CIRCULARES

El último elemento de la estructura esta “ligado” o enlazado con el primer

elemento de la misma. Generalmente se tiene un número específico de datos
que se pueden almacenar en la estructura y apuntadores al inicio y final de la
misma (Sáez X, 2010).

Figuran 7. Colas circulares (Herrera C, 2015).

Cuando un elemento se agrega se coloca al final de la estructura si hay

espacio y se recorre el puntero final, él elemento se elimina el puntero de inicio
recorre la estructura por lo tanto libera un lugar.

Figuran 8. Eliminación del puntero inicial (Herrera C, 2015)

 10

2.3.3. COLAS CON PRIORIDAD

Los elementos se agregan al final de la estructura pero el elemento que sale o

el primero es el de mayor importancia o prioridad.

Generalmente los elementos no están ordenados dentro de la estructura, sino

que el primer elemento (y segundo en ocasiones) es el que tiene mayor
prioridad.

Si existen dos o más elementos con la misma prioridad se toman conforme se

agregan a la estructura, como si fuera una cola simple (Sáez X, 2010).

2.3.4. COLAS DE DOBLE ENTRADA

Una bicola o cola de doble entrada es un conjunto ordenado de elementos al

que se pueden añadir o quitar elementos desde cualquier extremo del mismo.
El acceso a la bicola está permitido desde cualquier extremo, por lo que se
considera que es una cola bidireccional. La estructura bicola es una extensión
del TAD cola.(Joyanes L y Zanohero I 2009).

Los dos extremos de una bicola se identifican con los apuntadores frente y final
(mismos nombres que en una cola). Las operaciones básicas que definen una
bicola son una ampliación de las operaciones de una cola:

 Crear Bicola : inicializa una bicola sin elementos.

 Bicola Vacia: devuelve true si la bicola no tiene elementos.
 Poner Frente: añade un elemento por el extremo frente.
 Poner Final: añade un elemento por el extremo final.
 Quitar Frente: devuelve el elemento frente y lo retira de la bicola.
 Quitar Final: devuelve el elemento final y lo retira de la bicola.
 Frente: devuelve el elemento frente de la bicola.
 Final: devuelve el elemento final de la bicola
 11

2.3.4.1. BICOLA DE ENTRADA RESTRINGIDA

Según Herrera C. (2015) Se agregan elementos por ambos extremos de la

estructura, pero se eliminan solo por el inicio (front).

Figura 9. bicola de entrada restringida (Herrera C, 2015).

2.3.4.2. BICOLA DE SALIDA RESTRINGIDA

Se eliminan elementos por ambos extremos de la estructura, pero se agregan

solo por el final.

Figura 10. Bicola de salida restringida (Herrera C, 2015).

2.3.5. CARACTERISTICAS DE LAS COLAS

Las características es que los elementos se quitan de la cola en el mismo

orden en que se almacenan y, por consiguiente, una cola es una estructura de
tipo FIFO (first-in/first-out, primero en entrar/primero en salir o bien primero en
llegar/primero en ser servido)

Una cola generalmente se representa gráficamente de forma horizontal, sin

embargo, el frente (front) de la estructura es una señal para orientar su
funcionamiento:

Figura 11. Representación gráfica de una cola (Herrera C, 2015).

 12

2.3.6. OPERACIONES UTILIZADAS POR COLAS

 Crear cola: Inicia la cola como vacía

 Insertar: Añade un dato por el final de la cola
 Quitar Retira (extrae): el elemento frente de la cola
 Cola vacía: Comprobar si la cola no tiene elementos
 Cola llena: Comprobar si la cola está llena de elementos
 Frente: Obtiene el elemento frente o primero de la cola
 Tamaño de la cola: Número de elementos máximo que puede contener
la cola

2.3.7. METODOS PUSH Y POP

El método push ingresa elementos nuevos a la cola, la particularidad de las
colas es que los nuevos elementos se insertan al final de la cola (Herrera C,
2015).

Figura 12. Cola de números enteros (Herrera C, 2015).

En el método pop elimina o quita el primer elemento de la estructura, el

primero que se agregó

Figura 13. Método pop en cola (Herrera C, 2015).

FRONT: Indica cual es el primer elemento en la estructura (Herrera C, 2015)

BACK: Indica cual es el último elemento en la estructura.

 13

2.4. LISTAS
Según Joyanes L (2008). Una lista lineal es un conjunto de elementos de un
tipo de dato que puedan variar en número y donde cada elemento tiene un
único predecesor y un único sucesor o siguiente, excepto el primero y último de
la lista .esta es una definición muy general que incluye los ficheros y vectores.

Los elementos de una lista lineal se almacenan normalmente contiguos –un

elemento detrás de otro-en posición consecutivas de la memoria. Una lista
lineal se almacena en la memoria principal de la computadora en posiciones
sucesivas de memoria; cuando se almacenan en cinta magnética, los
elementos sucesivos se presentan en sucesión en la cinta. Esta asignación de
memoria se denomina almacenamiento secuencial. Posteriormente existe otro
tipo de almacenamiento denominado encadenado o enlazado.

Según Herrera C. (2015). Una lista generalmente se representa gráficamente

de forma horizontal, cada nodo cuenta con una división marcada de los datos y
los enlaces. Generalmente tiene un puntero especial al inicio de la lista, y en
algunas ocasiones se tiene un puntero que indica el final de la estructura.

Figura 14. Representación grafica de una lista (Herrera C, 2015).

2.4.1. ESTRUCTRURA DE UNA LISTA

Una lista enlazada consta de un número de elementos y cada elemento tiene

dos componentes (campos), un puntero al siguiente elemento de la lista y un
valor, que puede ser de cualquier tipo (Joyanes L y Zahonero I 2009).

Los enlaces se representan por flechas para facilitar la comprensión de la

conexión entre dos nodos.
 14

Figura 15. Representación de Enlace de nodos (Joyanes L y Zahonero I 2009).

2.4.2. LISTAS ENLAZADAS

Según Joyanes L. (2008). Una lista enlazada es un conjunto de elementos en

los que cada elemento contiene la posición o dirección del siguiente elemento
de la lista. Cada elemento en la lista enlazada debe tener al menos dos
campos; un campo que tiene el valor del elemento y un campo (enlace, link)
que contiene la posición del siguiente elemento, es decir, su conexión, enlace o
encadenamiento. Los elementos de una lista son enlazados por medio de los
campos de enlaces.

Figura 16. Representación de Listas Enlazadas (Joyanes L y Zahonero I 2009).

2.4.3. CLASIFICACION DE LAS LISTAS ENLAZADAS

Las listas se pueden dividir en cuatro categorías:

2.4.3.1. LISTAS SIMPLEMENTE ENLAZADAS ABIERTAS

Según Rodríguez L (2012). Se considera a la lista enlazada como una

estructura de datos recursiva. Si la lista está vacía, ésta será un puntero nulo,
Si tiene elementos, será un puntero que apunta a un nodo con los campos info,
con la información del elemento, y sig. Que será otra lista. Cada lista será o
bien un puntero nulo o un puntero al siguiente nodo.

Una lista estará compuesta por un conjunto de listas, la última de la cuales

estará vacía. Serán listas, tanto el puntero que indica la dirección del primer
elemento como cualquiera del campo siguiente.
 15

2.4.3.2. LISTAS SIMPLEMENTE ENLAZADAS CERRADAS

Las listas circulares o cerradas son aquellas en las que el último elemento
(nodo), tiene un enlace con el primero, por lo que al vacío su último elemento

como son los casos de las de esta forma el apuntador no corre el riesgo de
apuntar a una dirección que no sea la de un nodo que si pertenece a la lista.

abiertas,

Figura 17. Representación de Lista simplemente cerrada (Sáez X, 2010) .

2.4.3.3. LISTAS DOBLEMENTE ENLAZADAS ABIERTAS

Según Joyanes L y Zanohero I (2009).Son las listas en las que cada nodo
tiene un enlace con el elemento siguiente y con el anterior. Una ventaja que
tienen es que pueden recorrerse en ambos sentidos, ya sea para efectuar una
operación con cada elemento o para insertar/actualizar y borrar. La otra ventaja
es que las búsquedas son algo más rápidas puesto que ya hace referencia al
elemento anterior. Su inconveniente es que ocupan más memoria por nodo que
una lista simple. Tanto el siguiente al último, como el preliminar al primero
apuntan a la lista vacía.

2.4.3.4. LISTAS DOBLEMENTE ENLAZADAS CERRADAS

Estas listas son la combinación de los dos conceptos anteriores. Listas en

donde cada elemento apunta al siguiente y al anterior, además de apuntar el
último elemento al primero y el primero viceversa al último elemento de la lista.
Para su implementación se usa un nodo llamado centinela, que es el que
marca el inicio o fin de la lista, el cual tiene la misma característica de un nodo
normal, con sus tres campos, dos de apuntadores y el de dato, lo único que en
este último se pone una marca (dato acordado) para señalar la presencia del
centinela, aumentando la cantidad de memoria necesaria para esta estructura.
 16

2.4.4. OPERACIONES CON LAS LISTAS ENLAZADAS

Según Deitel P y Deitel H (2008). Una lista enlazada requiere realizar la gestión
de los elementos contenidos en ella. Estos controles se manifiestan en forma
de las operaciones básicas, especificadas al definir el tipo abstracto lista, que
tendrán las siguientes funciones:
 Declarar los tipos nodo y puntero a nodo.
 Inicializar o crear.
 Insertar elementos en una lista.
 Eliminar elementos de una lista.
 Buscar elementos de una lista (comprobar la existencia de elementos en
una lista).
 Recorrer una lista enlazada (visitar cada nodo de la lista).
 Comprobar si la lista está vacía.

2.4.5. ACCESO A UNA LISTA

La construcción y manipulación de una lista enlazada requiere el acceso a los

nodos de la lista a través de uno o más punteros a nodos. Normalmente, un
programa incluye un puntero al primer nodo (cabeza) y un puntero al último
nodo (cola).

2.4.6. INSERCION DE UN ELEMENTO EN UNA LISTA

El algoritmo empleado para añadir o insertar un elemento en una lista enlazada

varía dependiendo de la posición en que se desea insertar el elemento. La
posición de inserción puede ser:
 En la cabeza (elemento primero) de la lista.
 En el final de la lista (elemento último).
 Antes de un elemento especificado, o bien.
 Después de un elemento especificado.
 17

2.4.7. INSERCION DE UN NODO AL FINAL DE UNA LISTA

La inserción al final de la lista es menos eficiente debido a que, normalmente,

no se tiene un puntero al último elemento de la lista y entonces se ha de seguir
la traza desde la cabeza de la lista hasta el último nodo de la lista y a
continuación realizar la inserción. Cuando último es puntero que apunta al
último nodo de la lista, las sentencias siguientes insertan un nodo al final de la
lista:

2.4.8. BORRADO DE UN NODO EN UNA LISTA

La operación de eliminar un nodo de una lista enlazada implica enlazar el nodo

anterior con el nodo siguiente al que se desea eliminar y liberar la memoria que
ocupa

El algoritmo para eliminar un nodo que contiene un dato se puede expresar en

estos pasos o etapas:

 Búsqueda del nodo que contiene el dato. Se ha de tener la dirección del

nodo a eliminar y la dirección del anterior.
 El puntero siguiente del nodo anterior ha de apuntar al siguiente del
nodo a eliminar.
 En caso de que el nodo a eliminar sea el primero, cabeza, se modifica
cabeza para que tenga la dirección del nodo siguiente.
 Por último, se libera la memoria ocupada por el nodo.
 18

III. ANÁLISIS DE RESULTADOS

3.1. EJERCICIO DE PILAS

Realizar un programa para insertar números enteros a una pila, realizando un

menú con las opciones 1. Apilar, 2. Desapilar y 3. Salir, después mostrar los
números en forma de una pila (lifo).

#include<iostream>

#include<windows.h>

#include<conio.h> // Incluimos las librerias necesarias

using namespace std;

struct nodo{ //creamos una estructura nodo con campo dato d y

int d; // un nodo puntero llamado siguiente

nodo*siguiente;

};

typedef nodo*pnodo; //redefinimos la estructura nodo a pnodo

void insertar_pila(pnodo &pila,int n){ //función insertar_pila con dos parámetros

pnodo nuevo=new nodo(); // crear espacio en memoria para almacenar un nodo

nuevo->d=n; // cargar el valor dentro del nodo nuevo

nuevo->siguiente=pila; // nuevo en su parte siguiente apuntara a pila

pila=nuevo; // pila se actualiza a nuevo(pila =al nuevo nodo ingresado)

int mostrarpila(pnodo &pila){ // función mostrar_pila con un parámetro

int m; //declaramos una variable entera m

if(pila!=NULL){ // si la lista tiene un nodo o mas

pnodo aux=pila; // creamos una variable aux de tipo pnodo sea igual a pila

pila=aux->siguiente; // pila apuntara a lo que tiene aux en su parte siguiente

m=aux->d; // salvamos el valor del campo d del aux en la variable m

 19

delete aux; //eliminamos el aux

return m; //como la función es de tipo int retornamos el valor de m

int main(){

int opc; //declaramos una variable entera llamada opc

pnodo pila=NULL; // declaramos e inicializamos pila en NULL

int e; // declaramos una variable entera e

MENU: // utilizamos el goto menu

do{ // utilizamos un ciclo do while para realizar el menu de opciones

system("cls");

cout<<"|+++++++++++++++++++++++++++++|"<<endl;

cout<<"| +++++++ PROGRAMA PILA +++++|"<<endl;

cout<<"| 1. apilar |"<<endl;

cout<<"| 2. desapilar |"<<endl;

cout<<"| 3 . salir |"<<endl;

cout<<"|+++++++++++++++++++++++++++++|"<<endl;

cout<<" ingrese una opcion "<<endl;

cin>>opc;

}while(opc<1||opc>3 );

if(opc==1){ //si la opc es 1

cout<<"ingrese un valor a la pila: "<<endl;

cin>>e; // ingresamos valor a la pila por teclado

insertar_pila(pila,e); // llamamos a la funcion

goto MENU;

} if(opc==2) { //si la opcion es 2

 20

if(pila!=NULL){ // si la pila tiene uno a mas nodos

e=mostrarpila(pila); //los valores serán almacenados en la variable e

cout<<" el dato desapilado es : "<<e<<endl; // muestra el valor

}else{

cout<<"la pila esta vacia "; // no existe ningún nodo dentro de pila

getch();

goto MENU;

else{

goto fin;

fin:

cout<<" fin del programa "<<endl; //fin del programa

return 0;

}
 21

3.2. EJERCICIO DE COLAS

Realizar un programa en donde se inserten números enteros a una pila,

realizando un menú con las opciones 1. Encolar , 2. Desencolar y 3. Salir,
después mostrar los números en forma de una cola (fifo).

#include<iostream>

#include<windows.h>

#include<conio.h>

using namespace std;

struct nodo{ // creamos una estructura nodo con un campo dato dato

int dato; //y un nodo puntero llamado sig

nodo*sig;

};

typedef nodo*pnodo; //redefinimos la estructura nodo a pnodo

void push(pnodo &frente ,pnodo &fin ,int n){

pnodo nuevo=new nodo(); //crear espacio en memoria para almacenar un

nodo

nuevo->dato=n; // cargar el puntero dentro del nodo(*siguiente)

nuevo->sig=NULL; // nuevo en su parte sig es igual a NULL

if(frente==NULL){ // si frente no tiene ningún nodo creado

frente=nuevo; // frente es igual al primer nodo creado de la cola

}else{ //caso contrario si frente tiene más de un nodo

fin->sig=nuevo; //fin en su parte siguiente apuntara al nuevo ingresado

fin=nuevo; // fin es igual nuevo nodo creado

int pop(pnodo &frente,pnodo &fin){ // sacar elemetos de la cola

int x; // declaramos una variable entera x

 22

if(frente!=NULL){ //si frente no está vacía(tienes más de un nodo)

pnodo aux=frente; // cremos una variable aux de tipo pnodo sea=frente

x=aux->dato; // salvamos el dato en la variable entera x

frente=aux->sig; // frente apuntara al nodo apuntado por aux

delete aux; //eliminamos el aux

}else{

cout<<" la lista esta vacia ";

return x; //como la function es tipo int retornamos el valor de x

int main (){

int opc; // declaramos una variable entera opc

pnodo frente=NULL; //declaración e inicialización=NULL

pnodo fin=NULL; //declaración e inicialización de fin =NULL

int s; // declaramos una variable entera s

MENU: // utilizamos el goto menu

system("cls");

do{ //utilizamos un bucle do while para el menu

cout<< " datos en una cola " <<endl;

cout<<" 1. encolar "<<endl;

cout<<" 2. desencolar "<<endl;

cout<<" 3. salir "<<endl;

cout<<" ingrese opcion "<<endl;

cin>>opc;

}while(opc<1 || opc>3);

if(opc==1){ //si la opcion ingresada en el menú es igual a 1

 23

cout<< " INGRESE DATO A ENCOLAR:" <<endl;

cin>>s; //ingresamos el valor por teclado

push(frente,fin,s); // llamamos a la funcion push

system("cls");

goto MENU;

} if(opc==2){ // si la op es igual es a 2

if(frente!=NULL){ //si frente tiene más de un nodo

s=pop(frente,fin); // llamamos a la función y guardamos los datos en s

cout<<" el dato desencolado es "<<s<<endl;

getch();

goto MENU;

}else{

cout<<" la lista esta vacia "<<endl;

getch();

goto MENU;

else{

goto FIN;

FIN:

cout<<" fin de programa"<< endl;

return 0; }
 24

3.3. EJERCICIO DE LISTA

Realizar un programa de una lista simple insertando números enteros con un
menú de opciones que nos permita 1.Insertar, 2.mostrar, 3.Buscar, 4. Eliminar,
5.salir.

#include<iostream>

#include<conio.h>

#include<stdlib.h>

using namespace std;

struct nodo{ // creamos una estructura nodo con un campo dato

int dato; //y un nodo puntero sig

nodo *sig;

};

typedef nodo*pnodo; // redefinimos la estructura nodo a pnodo

void insertarLista(pnodo &lista,int a){

pnodo nuevo = new nodo(); // crear espacio en memoria para almacenar un

nodo

nuevo->dato = a; // asignamos el valor de a al campo dato de nuevo

pnodo aux = lista; // declaramos dos nodos aux e igualar a lista al primero
de

pnodo aux2; //ellos

while((aux != NULL) && (aux->dato < a)){ // insertamos datos de forma ordena

aux2 = aux; // aux2 se le asigna lo que tiene apuntando aux

aux = aux->sig; // aux apuntara lo que aux en su parte siguiente(recorre)

if(lista == aux){ //si la lista es igual al aux (si el nodo va al inicio)

lista = nuevo; // lista es igual al nuevo nodo creado

else{ // caso contrario (si el nodo va al medio o al final)

aux2->sig = nuevo;} // aux2 apuntara al nuevo nodo

 25

nuevo->sig = aux; // la parte sig del nuevo nodo apuntara a aux

cout<<"\tElemento "<<a<<" insertado en la lista correctamente\n";

void mostrarLista(pnodo lista){

pnodo aux = lista; //declaramos una variable aux de tipo pnodo sea =lista

if( aux!=NULL){

while(aux != NULL){ // recorremos la lista con el aux mientras no sea el

final de la lista

cout<<aux->dato<<" , ";

aux = aux->sig;

}else{

cout<<" la lista esta vacia "<<endl;

void buscarLista(pnodo lista,int n){

bool elemento = false; //declaramos una variable de tipo boolean sea=false

pnodo act = lista; //declaramos una variable act tipo pnodo sea=lista

while((act != NULL) && (act->dato <= n)){ //recorremos la lista

if(act->dato == n){

elemento = true;

act = act->sig;

if(elemento== true){ // se verifica si el elemento existe en la lista

cout<<" el elemento "<<n<<" a sido encontrado en la lista\n";

 26

else{

cout<<"el elemento "<<n<<" NO a sido encontrado en lista\n";

void eliminarNodo(pnodo &lista,int n){

if(lista != NULL){ // si la lista tiene un nodo o mas (no esta vacia)

pnodo aux; // declaramos una variable aux tipo pnodo

pnodo ult = NULL;

aux = lista;

while((aux != NULL) && (aux->dato != n)){

ult = aux;

aux = aux->sig;

if(aux == NULL){

cout<<"El elemento no ha sido encontrado \n";

else if(ult == NULL){

lista = lista->sig;

delete aux;

cout<<"El elemento a sido eliminado \n";

}else{

ult->sig = aux->sig;

cout<<"El elemento a sido eliminado \n";

delete aux;

}
 27

int main(){

pnodo lista=NULL; // declaramos e inicializamos a lista =NULL

int op; //declaramos una variable entera op

int dato;

menu: // utilizamos el goto

do{

system("cls");

cout<<" ejercicio de lista "<<endl;

cout<<" 1. insertar elementos a la lista "<<endl;

cout<<" 2. mostrar los elementos de la lista "<<endl;

cout<<" 3. buscar elemento a la lista "<<endl;

cout<<" 4. eliminar nodo de la lista "<<endl;

cout<<" 5. salir"<<endl;

cout<<" ingrese opcion "<<endl;

cin>>op;

}while(op<1||op>5);

if(op==1){

cout<<" Digite un numero a insertar : ";

cin>>dato;

insertarLista(lista,dato);

getch();

goto menu;

}if(op==2){

mostrarLista(lista);

getch();

goto menu;
 28

}if(op==3){

cout<<"\nDigite un numero a buscar: ";

cin>>dato;

buscarLista(lista,dato);

getch();

goto menu;

}if(op==4){

cout<<" Digite el dato que desea eliminar: ";

cin>>dato;

eliminarNodo(lista,dato);

system("pause");

goto menu;

}else{

cout<<" fin del programa"<<endl;

} return 0; }
 29

IV. CONCLUSIONES

El uso de los TDA nos ayuda a solucionar un sin número de problemas que
facilitan a desarrollar programas pero no obstante estas implementaciones
repercuten de manera negativa la implementación y comprensión. Estas
herramientas son complejas por lo que requiere tiempo y dedicación para la
correcta utilización en las pilas listas y colas. Por esto la memoria dinámica nos
permite trabajar mediante la utilización de punteros y eso a su vez gestionar el
espacio disponible dentro de la memoria y así crear o eliminar variable que
necesitemos durante la ejecución de un programa.

Las pilas son estructuras de datos en la que el modo de acceso a sus

elementos es de tipo LIFO (Last In Frist Out, el último en entrar, primero en
salir) que permite almacenar y recuperar datos. Esta estructura se aplica en
multitud de ocasiones en el área de informática debido a su simplicidad y
ordenación implícita en la propia estructura. Para el manejo de los datos se
cuenta con dos operadores básicos: apilar (push), que coloca un objeto en la
pila y su operación inversa retirar (pop), que retira el último elemento apilado.

Las colas se utilizan en sistemas informáticos, transportes y operaciones

de investigación (entre otros), dónde los objetos, personas o eventos son
tomados como datos que se almacenan y se guardan mediante colas para su
procesamiento.

Las listas son estructuras de datos fundamentales, puede ser usada para
implementar otras estructuras de datos. Consiste en una secuencia de nodos,
en donde se guardan campos de datos arbitrarios y una o dos referencias,
enlaces o punteros al nodo anterior o posterior. El principal beneficio de las
listas enlazadas respecto a los vectores convencionales es que el orden de los
elementos enlazados puede ser diferente al orden de almacenamiento en la
memoria, permitiendo que el orden de recorrido de la lista sea diferente al de
almacenamiento
 30

BIBLIOGRAFÍA

Deitel P y Deitel H . (2008) Como programar en c++. 6 ed. Mexico 804-808

Esquivel, K. (2010). Estructuras Dinámicas de Memoria. (En línea). PDF.

Consultado el 18 de julio del 2017. Disponible en:
http://antares.sip.ucm.es/cpareja/libroAlgoritmos/docs/Cap16-20.pdf

Herrera C. (2015). Estructura de datos lineales. (En línea) PDF. Consultado el

10 de julio del 2017 disponible en:
https://ri.uaemex.mx/bitstream/handle/20.500.11799/34615/secme-
19001.pdf;jsessionid=B1AC01678FBB41BD3C3FE304B8F6A7A1?se
quence=1

Joyanes L y Zahonero I. (2009). Programación en C, C++ Y Java y UML. 1

ed. México. p 964,966, 968, 970, 963, 977, 1061,1066

Joyanes L. (2008). Fundamentos de Programación 4 ed. México. p 431, 433,

452-454

Rodríguez L. (2012). Estructuras lineales de datos. (En línea) PDF. Consultado

el 14 de julio del 2017 disponible en:
http://www.colimbo.net/documentos/documentacion/113/FPII03_Estru
cturas_lineales_de_datos.pdf

Sáez X. (2010). Estructura de datos Básicas (En línea) PDF. Consultado el 20

de julio del 2017 disponible en:
http://www.cartagena99.com/recursos/alumnos/temarios/Estructuras
%20de%20datos%20basicas.pdf
31