REPÚBLICA BOLIVARIANA DE VENEZUELA

MINISTERIO DEL PODER POPULAR PARA LA DEFENSA

UNIVERSIDAD NACIONAL EXPERIMENTAL POLITÉCNICA DE LA FUERZA
ARMADA
NÚCLEO – ARAGUA

ESTRUCTURAS DE DATOS
PILAS Y COLAS

CARRERA: ING SISTEMAS NOMBRE: ABRAHAM

ROMÁN
SECCIÓN D1 C.I: 27.864.855
 INDICE

INTRODUCCIÓ……………………………………………………..………..3

DEFINA ESTRUCTURA DE DATOS…………………………..…………4

DEFINA PILAS Y COLAS…………………………………….……………..7

¿QUE SON LAS OPERACIONES BÁSICAS CON PILAS?...................12

DECLARACIÓN DE PILAS Y OPERACIONES SOBRE PILAS……….13

PILAS ALOJADAS EN ARREGLOS…………………………………….18

REPRESENTACIÓN DE COLAS………………………………….……..21

OPERACIONES CON COLAS…………………………………..….…….22

. COLAS CIRCULARES………………………………………..… …..23

DOBLE COLA Y APLICACIONES……………………………….……….24

¿QUÉ SON PILAS ENLAZADAS?........................................................24

IMPLEMENTACIÓN DINÁMICA DE PILAS Y COLAS……………….24

CONCLUSIÓN Y BIBLIOGRAFÍA……………………………………….32
 INTRODUCCIÓN

El presente material tiene como objetivo introducir al lector

de forma breve y sencilla al mundo de las estructuras de
datos dinámicas mediante la exposición de conceptos
sencillos de entender y la exposiciones de breves imágenes
que ayuden a una mejor compresión de los temas, cabe
destacar que los conocimientos que serán adquiridos
mediante este material son igualmente válidos para
innumerables lenguaje de programación con referencia a la
teoría expuesta aquí.

A parte de introducir al lector al mundo de las estructuras

de datos dinámicas mediante sus principios, estaremos
tratando mayormente el tema o las estructuras de datos
dinámicas del tipo pila y cola mediante su teoría y la
realización de breves ejercicios.
 ESTRUCTURA DE DATOS

En un principio, antes de adentrarnos al estudio de las estructuras de datos

dinámicas de tipo “pila” y “cola” se hace evidente que primero debemos estudiar
el concepto o los conceptos de “estructura” y “datos” para poder obtener un
verdadero entendimiento de dichos temas, y además, de obtener conocimiento
de dichos conceptos es prudente o muy importante profundizar un poco en la
teoría encerrado en lo que se conoce como “estructuras de datos”. A
continuación, daremos paso a las definiciones correspondientes y a la teoría
necesaria para poder continuar con el estudio o tratamiento de las “estructuras
de datos dinámicas de tipo pila y cola”.

Empecemos tratando el concepto fundamental que da esencia o en el cual se

basa el tema de las estructuras de datos, este concepto es el de la “estructura”.

*) Estructura: Una estructura es la disposición y organización de los elementos o

componentes de un todo, o, de forma más comprensible se tiene que una
estructura es el modo de estar organizadas u ordenadas las partes de un
todo. Un ejemplo genial del día a día sobre las estructuras son la conformación
o constitución de cualquier obra arquitectónica o “edificios”. Los elementos que
constituyen una construcción o edificio tienen una determinada distribución o
disposición y organización u orden particular que hace posible la existencia del
mismo. Tener en cuenta está analogía de lo que son las estructuras nos facilitará
en gran medida la comprensión del concepto de “estructura de datos” y esto se
verá cuando nos adentremos dentro de poco en la definición de “estructuras de
datos”.

Pasemos ahora a tratar de forma breve pero precisa el importante concepto o

definición de lo que es o lo que son los “datos”.

*) Dato: Un dato sencillamente es la representación de un hecho o suceso, dicha

representación se puede llevar a cabo mediante el uso de distintos símbolos
como las letras de alfabeto de cualquier idioma o la simbología aplicada en la
matemática. Las representaciones de hechos se pueden realizar mediante un
símbolo único o combinaciones de estos (pero, no necesariamente se puede
realizar con símbolos, también se pueden realizar a través de otras
herramientas). En las computadoras, hablando a nivel de los circuitos, los datos
como por ejemplo “el nombre de una persona” se representa mediante una
secuencia, sucesión u combinación de dígitos binarios, dichos dígitos binarios
son el 0 y el 1 los cuales simplemente representación el paso o abstención de
carga eléctrica. Las computadoras pueden interpretar estas series de pasos de
energía e interrupción de forma análoga como los seres humanos interpretamos
las letras del alfabeto o simbología matemática para obtener información. Los
datos que se usan en tiempo de ejecución en una computadora se almacenan
en la memoria principal de la máquina (mejor conocida como memoria RAM), la
máquina se encarga de asignar una parte o un bloque de memoria específico de
la memoria RAM para almacenar un dato según sea la necesidad.

Ya aclarado los anteriores conceptos, podemos empezar a tratar el concepto

de “estructuras de datos” teniendo la seguridad de que su comprensión no será
complicada.

*) Estructura de datos: Una estructura de datos en esencia es una colección de

datos que puede ser caracterizada por su “organización” y las operaciones que
se definen en ella. Otra forma de verlo es simplemente entender que las
estructuras de datos son formas particulares de organizar los datos en una
computadora o máquina para facilitar la manipulación de los mismos a través de
operaciones establecidas en determinadas estructuras.

Existen varias estructuras de datos las cuales se organizan o se clasifican en

dos grupos: Las estructuras de datos estáticas y dinámicas; A continuación,
enlistaremos las estructuras de datos más conocidas.

Estructuras de datos estáticas:

1) Arreglos o vectores (Conocidos también como Arrays).

2) Cadenas (mejor conocidos como Strings).

3) Registros.
4) Archivos (Conocidos también como ficheros).
 5) Conjuntos.

Estructuras de datos dinámicas:

1) Listas.

2) Listas enlazadas.

3) Pilas.

4) Colas.

5) Arboles.

6) Grafos.

- Estructuras de datos estáticas: Las estructuras de datos estáticas son todas

aquellas colecciones de datos organizados cuyo número de componentes o de
elementos se define antes de la ejecución de un programa. En consecuencia a
lo anteriormente dicho, las estructuras de datos estáticas son todas aquellas
cuyo espacio asignado de memoria es constante o invariable durante el
transcurso del programa, esto quiere decirnos que no se puede añadir más
elementos o datos a una estructura cuyo número de datos o componentes se
encuentra fijo, los datos dentro de la estructura pueden cambiar sin ningún
problema, sin embargo, no se pueden añadir más datos de lo que se estableció
en la programación o implementación de dicha estructura.

- Estructuras de datos dinámicas: Las estructuras de datos dinámicas son la

contraposición de las estructuras de datos estáticas, es decir, son aquellas
estructuras de datos cuyo número de elementos o componentes pueden variar
a través de la ejecución de un programa según sea necesario. En consecuencia,
a lo anteriormente dicho, son todas aquellas estructuras cuyo espacio de
almacenamiento asignado en la memoria RAM es variable y solamente se
encuentra limitado a la cantidad de memoria disponible de la misma.

Con las anteriores definiciones tratadas podemos empezar a entrar en materia

con las estructuras de datos dinámicas del tipo “pilas y colas”.
 ESTRUCTURAS DE DATOS DINÁMICAS DEL TIPO
PILAS Y COLAS

Antes de entrar con las definiciones de pilas y colas se hace de vital

importancia definir una estructura de datos anterior a estas dos ya que, las pilas
y las colas se originan gracias a esta, estoy hablando de la estructura de datos
del tipo “lista”. Trataremos brevemente la definición de las estructuras de datos
del tipo lista para una mejor comprensión de la definición de las pilas y las colas
ya que estas se originan gracias a las listas.

*) Listas: Una estructura de datos del tipo lista es una colección de datos que se
almacenan de forma consecutiva en la memoria principal de una computadora y
que cuyo número de elementos puede variar a través de la ejecución de un
programa (su asignación de memoria no está limitada apropósito, pero si se
encuentra limitada por la capacidad de la memoria principal de la maquina). Los
elementos que pertenecen a una lista son denominados “nodos de la lista” y
estos se acceden de forma secuencial. Podemos pensar en las listas como una
especie de “vectores” cuyo número de elementos puede variar. Es posible
eliminar, insertar, buscar, copiar, determinar el tamaño, clasificar y dividir una
lista.

Los nodos de una lista se encuentran constituidos por dos campos (Podemos
tratar a los nodos como simples registros), un campo que almacena el valor de
dicho nodo y un campo que almacena la dirección del siguiente nodo(Es decir
un puntero). Al último elemento de una lista en su campo puntero simplemente
apuntara al valor NULL.
 Es importante entender cómo se constituyen los nodos o los elementos
de una lista ya que de la misma forma lo harán los nodos de las pilas y las
colas debido a que estas dos estructuras de datos son tipos de listas
especiales cuya única diferencia con las pilas normales son la forma en
que se realizan las operaciones con ellas, lo cual se tratará en su momento.

Ahora nos encontramos en condiciones para la definición de pilas y colas.

*) Pilas: Las pilas son un tipo de estructura de datos dinámica que son muy
similares a las listas y solo se diferencia de las mismas por la forma de introducir
y extraer o borrar datos de las mismas. En las pilas la inserción y borrado de
elementos de la misma solo se realiza en un solo extremo de la misma el cual
se le denomina cima o tope. Debido a que los elementos solo se pueden
introducir y borrar 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 coloca en la pila es el primero que se puede sacar; Gracias a esto a las pilas
también se les conoce por estructuras LIFO (Last-in, first-out: Último en entrar,
primero en salir).
 Existen muchas analogías que permiten entender el concepto de pila, ya que
estas se presentan en la vida real, un magnífico ejemplo es una pila de platos.
 Si quisiéramos obtener el plato que se encuentra más debajo de la pila,
debemos ir retirando uno a uno los platos que se encuentren en la cima o arriba
de la pila, ya que si sacamos el plato de abajo directamente los demás
simplemente se romperán.

*) Colas: Las colas son otras estructuras de datos que se parecen a las listas al
igual de como lo hacen las pilas. La diferencia de las colas con respecto a las
listas y las pilas también es la forma o manera en que se insertan y borran datos
de la misma. En las colas la eliminación de elementos se realiza al principio de
la misma y las inserciones se realizan al final de la misma. El elemento que entro
primero sale también de primero, es por esto que a las colas las conocen también
como estructuras FIFO (First-in, first-out: Primero en entrar, primero en salir).
 También existen muchas analogías en la vida real sobre las colas, las cuales
nos puede aclarar mucho mejor cómo funcionan las mismas. Un gran ejemplo
para esto serían las colas de espera para comprar un boleto para ver una película
directamente en el cine, las personas que lleguen primero serán las que podrán
comprar el boleto primero y en consecuencia saldrán primero que los demás, en
cambio, las que lleguen más tarde tardarán mucho más en comprar el boleto ya
que primero deberán comprarlo primero las personas que tenga delante y
posteriormente podrá comprar su boleto y luego salir de la cola.
¿QUE SON LAS OPERACIONES BÁSICAS CON PILAS?

Las operaciones básicas con las pilas son todas aquellas acciones principales
que se pueden realizar con estas, las más usuales son las operaciones de
insertar(push) y eliminar(pop) datos o elementos (formalmente llamados nodos).

*) Operación push: Es la operación de insertar un elemento en la pila. Esta

operación normalmente se realiza a través de un procedimiento que se debe
definir durante la programación del software.

*) Operación pop: Es la operación de eliminar un elemento de la pila. Esta

operación normalmente se realiza a través de un procedimiento que se debe
definir durante la programación del software.
 Las dos operaciones definidas anteriormente son las principales, sin embargo,
se enlistarán a continuación estás y otras operaciones con ellas.

1) Crear: se crea la pila vacía.

2) Apilar: se añade un elemento a la pila. (push)

3) Desapilar: se elimina el elemento frontal de la pila. (pop)

4) Cima: devuelve el elemento que está en la cima de la pila. (top

o peek)

5) Vacía: devuelve cierto si la pila está vacía o falso en caso

contrario.

DECLARACIÓN DE PILAS Y OPERACIONES SOBRE

PILAS

La declaración de las pilas puede variar con respecto a los lenguajes de

programación utilizados en el momento, por ejemplo, en C++ se pueden
implementar normalmente de dos formas distintas, la primera de ellas es la
creación de los nodos de una pila mediante la implementación de registros (Uso
de la sentencia struct) y la otra forma mediante el uso de las clases. En
JavaScript la implementación de las pilas y las colas es muchísimo más sencillo,
ya que en dicho lenguaje vienen integradas las funciones o mejor dicho, la
implementación de las mismas.

La implementación de las listas, pilas y colas se encuentran plasmadas en

algoritmos elaborados por informáticos desde hace unos años atrás, esto quiere
decir que simplemente siguiendo las técnicas ya elaboradas por expertos en
tiempos pasados es suficiente para la implementación correcta de las listas y sus
derivados, asi como existen ya pseudocódigos que nos enseñan a como
estructurar una pila(o los nodos de la misma), también existen pseudocódigos
que nos muestran la forma de crear los procedimientos para la realización de
operaciones con estas estructuras de datos.
 Explicaremos la implementación y las operaciones sobre una pila a través de
un sencillo ejemplo, cuyo enunciado es el siguiente: Hacer un programa para
agregar números enteros a una pila, hasta que el usuario lo decida,
después mostrar todos los números introducidos en la pila.

El ejercicio será realizado mediante el lenguaje de programación C++

1) En primer lugar, debemos definir la estructura de los nodos de la pila, lo cual

se realiza mediante la implementación de las siguientes líneas de código.

Podemos observar que los nodos que implementaremos en este ejercicio se

encuentran constituidos por dos campos, un campo que almacena un entero (el
valor del nodo) y otro campo que almacena o almacenará la dirección de
memoria del siguiente nodo que se introduzca.

2) Ya tenemos la estructura de los nodos elaboradas, ahora pasaremos a crear

los procedimientos para insertar y eliminar elementos o nodos en una pila.
 Podemos observar en esta imagen a dos procedimientos, el procedimiento
“agregar pila” y el de “sacar pila”, como sus nombres lo indican realizan las
operaciones de push y pop en la pila. El procedimiento agregarPila recibe como
parámetros a una pila que luego declararemos, lo recibe mediante el paso de
parámetros por referencia y también recibe un entero “n” que será el valor del
nuevo nodo a introducir en la pila, en la línea 50 se define un nuevo puntero del
tipo “Nodo” y a su vez se reserva un espacio de memoria para introducir los
valores del nuevo nodo, en la línea siguiente mediante el operador flecha se
accede al campo dato del nuevo nodo y se le asigna el valor n que será recibido
mediante paso de parámetros, en la línea 52 accedemos al campo siguiente el
cual guardará en un primer momento la dirección de “pila” cuyo valor al principio
será NULL ya que desde un principio la pila estará vacía y además “pila” al ser
originalmente un puntero, apuntará al primer elemento o siguiente nodo que se
inserte en la misma y finalmente imprimiremos en pantalla un mensaje de
confirmación de que el elemento se ha introducido correctamente.

El procedimiento sacarPila recibe como parámetros por referencia al punto pila

y también la dirección de memoria de un entero n, posteriormente se implementa
la ayuda de un puntero auxiliar que almacenara la dirección del nodo de la pila a
eliminar, posteriormente se provoca que pila apunte a la dirección del nodo que
viene luego del nodo que será eliminado y finalmente como auxi almacena el
nodo que será eliminado, simplemente con el operador delete destruimos el nodo
liberando el espacio de memoria que se encontraba asignado para este.
3) Ya tenemos lo necesario para implementar la pila en el ejercicio que se nos
pide resolver, ahora implementando todo esto en el programa final se vería
así.
.En la línea 18 se declara la pila(Formalmente se declara un puntero
del tipo Nodo que apunta hacia NULL ya que al principio no existen
elementos dentro de la pila).La variable de tipo char llamada rpt
simplemente almacenará la respuesta del usuario sobre si quiere
agregar un nuevo elemento a la pila o no, la variable dato almacenará
el entero que el usuario desee guardar en la pila. En la línea 23 se
emplea el bucle do-while con el fin de poder realizar todas las
inserciones de nuevos elementos que el usuario ingresará en la
primera iteración del blucle y en las posteriores(si este lo desea), en
la línea 26 se llama al procedimiento agregarPila y se le pasan los
parámetros “pila” y dato, al final del bloque de instrucción do se le
pregunta al usuario si este quiere continuar introduciendo datos en la
pila y en caso de introducir “s” se repetirá el proceso y en caso de
introducir “n” se finalizará el proceso de introducir elementos y por
consecuencia el bucle habrá terminado.

En la línea 33 mostramos en pantalla el mensaje que se empezará

a mostrar los elementos de la pila y posteriormente empleamos un
bucle while con la condición de que pila no apunte a NULL, ya que si
lo hace simplemente se habrán acabado los elementos de la pila,
esto se hace con el propósito de ir recorriendo la pila(los valores
almacenados de ella) y a su vez ir eliminando dinámicamente los
nodos. En la línea 35 invocamos al procedimiento sacarPila el cual
recibe por referencia al puntero del tipo Nodo llamado pila y a su vez
recibe por referencia al entero dato, comprobamos mediante if si el
punto pila apunta hacia el elemento NULL, si no es así se mostrará
el valor del último nodo eliminado y en caso contrario simplemente
se imprimirá un punto de la pantalla indicando que todos los nodos
fueron eliminados.

El resultado final se muestra en la siguiente imagen

 PILAS ALOJADAS EN ARREGLOS

Otro de los métodos que se utiliza para la implementación de las pilas no

involucra la creación de variables dinámicas de un tipo definido por el usuario en
tiempo de ejecución, sino, en cambio utilizada arreglos para implementarlas.
Cuando se implementan pilas mediante arreglos lo que se hace en realidad es
simular el comportamiento de las pilas y no son pilas reales como tal, esto es
debido a que la cantidad de elementos que puede contener la pila es limitada o
estática y no se pueden agregar una cantidad indeterminada de datos a ella. La
implementación de las pilas con arreglos involucra una ventaja y una desventaja,
la ventaja de implementarlas de esta forma es que se tiene un control medido
del consumo de memoria principal de la máquina y la desventaja es que la
cantidad de elementos que pueden haber en una pila es limitada y muchas veces
no es posible determinar cuántos elementos realmente se necesitarán manejar
durante el transcurso del programa, si la cantidad de elementos que se necesita
manejar es muy grande y el tamaño del arreglo que simula la pila no es lo
suficientemente grande se provocara lo que se llama desbordamiento de
pila(stack overflow) lo que puede provocar consecuencias considerables en el
transcurso de la ejecución del programa ya que existe la posibilidad de corromper
el valor de un bloque de memoria ocupado por el mismo programa(en el mejor
de los casos) o se puede corromper el valor de un bloque de memoria ocupado
por un proceso del sistema operativo de la máquina.

En el programa que se verá en seguida, se simula el comportamiento de una

estructura de pila. Esta vez haremos uso de la programación orientada a objetos
para facilitar dicha tarea. Es de vital importancia aclarar y recordar que la
implementación de las pilas en la vida laboral se realiza de forma totalmente
dinámica y no simulada.
 REPRESENTACIÓN DE COLAS

Las estructuras dinámicas de datos de tipo cola se pueden representar de dos

formas distintas, como estructuras dinámicas naturales o, como arreglos. Para
la representación de las colas se necesitan simplemente dos punteros uno al que
llamaremos frente y otro al que llamaremos final y por último la lista o arreglo de
n elementos.
 El puntero llamado frente como su nombre lo indica apuntará al primer
elemento de la cola y el puntero llamado final apuntará al último elemento de la
cola así como se muestra en la figura anterior. Estos punteros se representan de
esta forma para indicarnos de forma implícita o recordarnos como se realizan las
operaciones con las colas.

OPERACIONES CON COLAS

Las operaciones que se pueden realizar con las colas son exactamente las
mismas que con las pilas o las listas, simplemente lo único que cambia es el
efecto que estas tienen sobre las colas, ya que las colas son estructuras de tipo
FIFO(first-in,first-out: primero en entrar, primero en salir), las operaciones de
insertar elementos se aplican al extremo superior de la cola(operación push) y
la operación de eliminar datos de la cola se aplica al elemento que se encuentra
en el extremo inferior de la cola(operación shift).

Ya aclaramos de forma breve las dos operaciones más relevantes de las colas,
ahora pasaremos a enlistar las operaciones que se pueden realizar con las colas.

1) Acceder al primer elemento de la cola.

2) Añadir un elemento al final de cola.

3) Eliminar el primer elemento de la cola.

4) Vaciar la cola.

5) Verificar el estado de la cola: vacía o llena.

 COLAS CIRCULARES

Las colas circulares son una mejora de las colas simples, son estructuras de datos
dinámicas en la cual el siguiente elemento del último de la cola es en realidad el primer
elemento de la cola

La forma de obtener una cola circular simplemente es que el campo de

“siguiente”(el cual es un puntero que guarda la dirección del siguiente nodo)
del último nodo no apunte a la dirección NULL, sino que apunte al primer
elemento o al elemento más antiguo de la lista.

Las colas circulares manejan las mismas operaciones que las colas simples.
 DOBLE COLA Y APLICACIONES

Las dobles colas son otra variante de las colas. La doble cola es una cola cuyas
operaciones de inserción y eliminación se pueden realizar en cualquier de los
dos extremos de la misma

Aplicación: Las doble colas son muy utilizadas en los sistemas operativos de
las computadoras como por ejemplo “WINDOW”, los procesos internos que se
llevan a cabo en el sistema están constantemente peleando por los recursos de
la computadora pero esta batlla se controla mediante un orden o “cola de
prioridades”, el proceso que sea más urgente a ejecutar será el que se ejecute
primero y el de menos urgencia lo hará al final de todos los demás, sin embargo,
los procesos pueden cambiar su prioridad de un momento a otro cuando el
usuario empieza a realizar acciones especificas esto provoca que hayan
procesos que tenian una prioridad baja y se ejecutaban a lo último deban
ejecutarse de forma inmediata, es decir, deben pasar al principio de la cola y si
hablamos en términos de la teoría brevemente explicada, se debe realizar la
operación de eliminación(es decir, ejecución en tiempo real) de proceso más
urgente y para conseguir que este proceso quede al principio de una cola solo
es posible utilizando una estructura de doble cola.

¿QUÉ SON PILAS ENLAZADAS?

 Las pilas enlazadas son una estructura de datos cuyos elementos o nodos no
se almacenan de forma secuencial, sino, de forma dispersa en la memoria y
estas solamente se quedan “enlazadas” gracias a los campos de dirección que
guardan la dirección de memoria del elemento que los antecede o los sucede. A
diferencia de las listas y las pilas y colas normales, el acceso a las pilas
enlazadas no es de forma secuencial(de una dirección de memoria a otra que
está a su lado o la sucede) sino que la maquina debe ir saltanto de dirección en
dirección de memoria a traves de su memoria principal. Esta estructura suelen
ser particularmente mucho más rápidas que las originales y más eficaces en
cuanto a la administración de memoria ya que los datos pueden estar dispersos
y almacenarse en espacios a traves de la memoria principal con más seguridad
de conseguir un bloque libre para ese nodo.

IMPLEMENTACIÓN DE PILAS Y COLAS

*) Ejemplo de implementación de pilas

#include <iostream>
using namespace std;
struct nodo{
int nro; struct nodo *sgte;
};
typedef nodo typedef nodo *ptrPila; *ptrPila; // creando // creando nodo tipo
puntero( tipo puntero( tipo de tipo de dato )
/* Apilar elemento elemento
---------------------------------------------------------------------*/
void push( ptrPila &p, int valor )
{
ptrPila aux;
aux = new(struct nodo); (struct nodo); // apuntamos // apuntamos al nuevo al
nuevo nodo creado nodo creado
aux->nro = valor;
aux->sgte = p ;
p = aux ;
}
/* Desapilar Desapilar elemento(devuelve elemento(devuelve elemento)
elemento)
---------------------------------------------------------------------*/
int pop( ptrPila &p )
{
int num ;
ptrPila aux;
aux = p ;
num = aux->nro; aux->nro; // asignamos // asignamos el primer el primer vamor
de vamor de la pila la pila
p = aux->sgte ;
delete(aux);
return num;
}
/* Muestra Muestra elementos elementos de la pila
---------------------------------------------------------------------*/
void mostrar_pila( ptrPila p )
{
ptrPila aux;
aux = p; // apunta al inicio de la lista
while( aux !=NULL )
{
cout<<"\t"<< cout<<"\t"<< aux->nro aux->nro <<endl; <<endl;
aux = aux->sgte;
}}
/* Eliminar Eliminar todos los elementos elementos de la pila
---------------------------------------------------------------------*/
void destruir_pila( ptrPila &p)
{
ptrPila aux;
while( p != NULL)
{
aux = p;
p = aux->sgte;
delete(aux);
}}
/* Menu de opciones opciones
----------------------------------------------------------------------*/
void menu()
{
cout<<"\n\t IMPLEMENTACION DE PILAS EN C++\n\n";
cout<<" cout<<" 1. APILAR "<<endl; "<<endl;
cout<<" cout<<" 2. DESAPILAR DESAPILAR "<<endl; "<<endl;
cout<<" cout<<" 3. MOSTRAR MOSTRAR PILA "<<endl; "<<endl;
cout<<" cout<<" 4. DESTRUIR DESTRUIR PILA "<<endl; "<<endl;
cout<<" cout<<" 5. SALIR "<<endl; "<<endl;
cout<<"\n INGRESE OPCION: ";
}
/* Funcion Funcion Principal Principal
----------------------------------------------------------------------*/
int main() {
ptrPila p ptrPila p = NULL; = NULL; // creando // creando pila
int dato;
int op;
int x ; // numero que devuelve la funcon pop
system("color 0b");
do
{
menu(); menu(); cin>> op;
switch(op)
{
case 1:
cout<< "\n NUMERO A APILAR: "; cin>> dato;
push( p, dato );
cout<<"\n\n\t\tNumero " << dato << " apilado...\n\n";
break;
case 2:
x = pop( p );
cout<<"\n\n\t\tNumero "<< x <<" desapilado...\n\n";
break;
case 3:
cout << "\n\n MOSTRANDO PILA\n\n";
if (p!=NULL)
mostrar_pila( p );
else
cout<<"\n\n\tPila vacia..!"<<endl;
break;
case 4:
destruir_pila( p );
cout<<"\n\n\t\tPila eliminada...\n\n";
break; }
cout<<endl<<endl;
system("pause"); system("cls");
}
while
(op!=5);
return 0;
}

*) Ejemplo de implementación de colas:

#include <iostream>
#include <stdlib.h>
using namespace std;
/* Estructura Estructura de los nodos de la cola
-----------------------------------------------------------------*/
struct nodo
{
int nro;
struct nodo *sgte;
};
/* Estructura Estructura de la cola
-----------------------------------------------------------------*/
struct cola
{
nodo *delante;
nodo *atras ;
};
/* Encolar Encolar elemento elemento
------------------------------------------------------------------*/
void encolar( struct cola &q, int valor )
{
struct nodo *aux = new(struct nodo);
aux->nro = valor;
aux->sgte = NULL;
if ( q.delante == NULL)
q.delante q.delante = aux; // encola el primero elemento primero elemento
else
(q.atras)->sgte = aux;
q.atras q.atras = aux; // puntero puntero que siempre siempre apunta al ultimo
elemento elemento
}
/* Desencolar Desencolar elemento elemento
------------------------------------------------------------------*/
int desencolar( struct cola &q )
{
int num ;
struct nodo *aux ;
aux = q.delante; q.delante; // aux apunta al inicio de la cola
num = aux->nro;
q.delante = (q.delante)->sgte;
delete(aux); delete(aux); // libera memoria memoria a donde apuntaba apuntaba
aux
return num; }
/* Mostrar Mostrar Cola
-------------------------------------------------------------------*/
void muestraCola( struct cola q )
{
struct nodo *aux;
aux = q.delante;
while( aux != NULL )
{
cout<<" cout<<" "<< aux->nro aux->nro ;
aux = aux->sgte;
}}
/* Eliminar Eliminar todos los elementos elementos de la Cola
-------------------------------------------------------------------*/
void vaciaCola( struct cola &q)
{
struct nodo *aux;
while( q.delante != NULL)
{
aux = q.delante;
q.delante = aux->sgte;
delete(aux);
}
q.delante = NULL;
q.atras q.atras = NULL;
}
/* Menu de opciones opciones
--------------------------------------------------------------------*/
void menu()
{
cout<<"\n\t IMPLEMENTACION DE COLAS EN C++\n\n"; cout<<" cout<<" 1.
ENCOLAR ENCOLAR "<<endl; "<<endl;
cout<<" cout<<" 2. DESENCOLAR DESENCOLAR "<<endl; "<<endl;
cout<<" cout<<" 3. MOSTRAR MOSTRAR COLA "<<endl; "<<endl;
cout<<" cout<<" 4. VACIAR COLA "<<endl; "<<endl;
cout<<" cout<<" 5. SALIR "<<endl; "<<endl;
cout<<"\n INGRESE OPCION: ";
}
/* Funcion Funcion Principal Principal
--------------------------------------------------------------------*/
int main()
{
struct cola q;
q.delante = NULL;
q.atras q.atras = NULL;
int dato; int dato; // numero // numero a encolar encolar
int op; // opcion del menu
int x ; // numero que devuelve devuelve la funcon pop
system("color 0b");
do
{
menu(); menu(); cin>> op;
switch(op)
{
case 1:
cout<< "\n NUMERO A ENCOLAR: "; cin>> dato;
encolar( q, dato );
cout<<"\n\n\t\tNumero " << dato << " encolado...\n\n";
break
;
case 2:
x = desencolar( q );
cout<<"\n\n\t\tNumero "<< x <<" desencolado...\n\n";
break;
case 3:
cout << "\n\n MOSTRANDO COLA\n\n";
if (q.delante!=NULL) muestraCola( q );
else cout<<"\n\n\tC cout<<"\n\n\tCola vacia...!"<< vacia...!"<<endl;
break;
case 4:
vaciaCola( q );
cout<<"\n\n\t\tHecho...\n\n";
break; }
cout<<endl<<endl;
system("pause"); system("cls");
}while(op!=5);
return 0; }

CONCLUSIÓN

Hemos podido adentrarnos al mundo de las estructuras de datos dinámicas de

forma sencilla y fácil de comprender gracias al material presentado, con lo cual
hemos concluido el objetivo de este material de dar una introducción precisa y
sencilla sobre las pilas y colas y profundizando un poco más alla de sus
conceptos para entender mejor como trabajan las máquinas que tanto
necesitamos en nuestro día a día.

Bibliografía:

1) FUNDAMENTOS DE PROGRAMACIÓN – Luis Joyanes Aguilar; MC

GRAW HILL

2) COMO PROGRMAR EN C++: deitel y deitel; Prentice Hall