INSTITUTO TECNOLOGICO

DE VERACRUZ
NOMBRE DEL ALUMNO:
DE LA PAZ REYES SOFIA KARINA #CONTROL: E13020011
CRUZ RAMOS JESUS ALEJANDRO #CONTROL: E13020010
OSORNIO RAMIRES DIEGO ALBERTO #CONTROL: E13020064

MATERIA:
ESTRUCTURA DE DATOS 10 -11 hrs.

CATEDRATICO:
BARRADAS BALLESTEROS BERNARDO LUIS

NOMBRE DEL TRABAJO:

UNIDAD II: PILAS Y COLAS (SIMPLES Y CIRCULARES)

OBSERVACIONES:
________________________________________________________________________________
____________________________________________________________

____________________
FIRMA

INDICE
INTRODUCCION

3
1

2.- PILAS

2.2 Que es una pila?

2.3 Operaciones bsicas de una pila
2.4 Implementacin
2.4.1 Mediante array
2.4.2 Mediante lista enlazada
2.5 Ejemplo 1: Pila de productos y cdigos
2.5.1 Ejemplo 2: Pila que almacene artculos
deportivos

2.5.2 Ejemplo 3: Programa Para Control De

Reserva de Aviones

CONCLUSION
REFERENCIAS
INTRODUCCION

4
5
7
7
8
10

14

17
25
26

La presente investigacin se refiere al tema de pilas sobre estructura de datos en las cuales
podemos definirlas de una manera simple como un tipo especial de lista lineal en la que la insercin y
borrado de nuevos elementos se realiza slo por un extremo que se denomina cima o tope (top). Dado
2

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 inserta 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 le conoce por el nombre de
LIFO (last-in, first-out, ltimo en entrar, primero en salir).
La mayora de algoritmos que desarrollaremos se centrarn en la repeticin de un conjunto de
acciones sobre una secuencia de datos. Ah radica la importancia de saber trabajar con las pilas. Sin
ir ms lejos, en asignaturas anteriores ya habis estudiado los esquemas de recorrido y bsqueda en
una secuencia. Pero adems, aparte de la importancia del tratamiento de las pilas, en este mdulo
averiguaremos cmo se almacenan de manera que posteriormente podamos acceder a ellas
secuencialmente.

PILAS
QUE ES UNA PILA?
Una pila representa una estructura lineal de datos en que se puede agregar o quitar elementos nicamente por
uno de los dos extremos. En consecuencia, los elementos de una pila se eliminan en el orden inverso al que se
insertaron. Debido a est caracterstica, se le conoce como estructura LIFO (last input, first output).
Existen muchos casos prcticos en los que se utiliza la idea de pila: Ejemplo; pila de platos, en el
supermercado latas. Las pilas con estructuras lineales como los arreglos, ya que sus componentes ocupan
lugares sucesivos en la ED y c/u tienen un nico sucesor/predecesor, con excepcin del primero/ltimo.
Las pilas no son estructuras fundamentales de datos; es decir no estn definidas como tales en los lenguajes
de programacin. Para su representacin requieren de otras EDs, como: Arreglos, Listas
3

Es importante definir el tamao de la mximo de la pila, as como una variable auxiliar que se denomina TOPE.
Est variable se utiliza para indicar el ltimo elemento que se insert en la pila.
Al utilizar arreglos para implementar pilas se tiene la limitacin de que se debe reservar el espacio en
memoria con anticipacin. Una vez dado un mximo de capacidad a la pila no es posible insertar un nmero de
elementos mayor que el mximo establecido. Si esto ocurre, en otras palabras si la pila esta llena y se intenta
insertar un nuevo elemento, se producir un error conocido como desbordamiento overflow.

OPERACIONES BASICAS DE UNA PILA

1. PUSH (INSERTAR)
En primer lugar hay que decir que esta operacin es muy comnmente denominada push.
La insercin en una pila se realiza en su cima, considerando la cima como el ltimo elemento insertado. Esta es
una de las particularidades de las pilas, mientras el resto de estructuras de datos lineales se representan
grficamente en horizontal, las pilas se representan verticalmente. Por esta razn es por lo que se habla de
cima de la pila y no de cola de la cima. Aunque en el fondo sea lo mismo, el ltimo elemento de la estructura de
datos.

Las operaciones a realizar para realizar la insercin en la pila son muy simples, hacer que el nuevo nodo apunte
a la cima anterior, y definir el nuevo nodo como cima de la pila.
Vamos a ver un ejemplo de una insercin:

Al insertar sobre esta pila el elemento 0, la pila resultante sera:

2. POP (REMOVER)

Esta operacin es normalmente conocida como pop.

Cuando se elimina un elemento de la pila, el elemento que se borra es el elemento situado en la cima de la pila,
el que menos tiempo lleva en la estructura.
Las operaciones a realizar son muy simples, avanzar el puntero que apunta a la cima y extraer la cima anterior.
Si aplicamos la operacin pop a la pila de 4 elementos representada arriba el resultado sera:

3. VACIA
Regresa un valor booleano indicando si la cola tiene o no elementos (true si la cola esta vaca, false si la cola
tiene al menos un elemento).

4. LLENA
Regresa un valor booleano indicando si la cola tiene espacio disponible para insertar nuevos elementos ( true
si esta llena y false si existen espacios disponibles).

IMPLEMENTACIN
MEDIANTE ARRAY
Esta implementacin es esttica, es decir, da un tamao mximo fijo a la pila, y si se sobrepasa dicho lmite se
produce un error. La comprobacin de apilado en una pila llena o desapilado en una pila vaca no se han hecho,
pero s las funciones de comprobacin, que el lector puede modificar segn las necesidades de su programa.
- DECLARACIN:

struct tpila
{
int cima;
int elementos[MAX_PILA];
};
Nota: MAX_PILA debe ser mayor o igual que 1.

- PROCEDIMIENTO DE CREACIN:

void crear(struct tpila *pila)

{
pila->cima = -1;
}

- FUNCIN QUE DEVUELVE VERDADERO SI LA PILA EST VACA:

int vacia(struct tpila *pila)

{
return (pila->cima == -1);
}
6

- FUNCIN QUE DEVUELVE VERDADERO SI LA PILA EST LLENA:

int llena(struct tpila *pila)

{
return (pila->cima == MAX_PILA);
}

- PROCEDIMIENTO DE APILADO:

void apilar(struct tpila *pila, int elem)

{
pila->elementos[++pila->cima] = elem;
}

- PROCEDIMIENTO DE DESAPILADO:

void desapilar(struct tpila *pila, int *elem)

{
*elem = pila->elementos[pila->cima--];
}

IMPLEMENTACIN MEDIANTE LISTA ENLAZADA

Para hacer la implementacin se utiliza una lista con cabecera ficticia (ver apartado de listas). Dado el carcter dinmico
de esta implementacin no existe una funcin que determine si la pila est llena. Si el usuario lo desea puede implementar
un anlisis del cdigo devuelto por la funcin de asignacin de memoria.
- Declaracin:
struct tpila
{
int clave;
struct tpila *sig;
};
- Procedimiento de creacin:
void crear(struct tpila **pila)
{
*pila = (struct tpila *) malloc(sizeof(struct tpila));
(*pila)->sig = NULL;
}
- Funcin que devuelve verdadero si la pila est vaca:
int vacia(struct tpila *pila)

return (pila->sig == NULL);

}
- PROCEDIMIENTO DE APILADO (APILA AL COMIENZO DE LA LISTA):
void apilar(struct tpila *pila, int elem)
{
struct tpila *nuevo;
nuevo = (struct tpila *) malloc(sizeof(struct tpila));
nuevo->clave = elem;
nuevo->sig = pila->sig;
pila->sig = nuevo;

}
- PROCEDIMIENTO DE DESAPILADO (DESAPILA DEL COMIENZO DE LA LISTA):
void desapilar(struct tpila *pila, int *elem)
{
struct tpila *aux;

aux = pila->sig;
*elem = aux->clave;
pila->sig = aux->sig;
free(aux);

EJEMPLO 1: Pilas de productos con cdigo

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

#include <ctype.h>

struct productos
{
int codigo;
char nombre[50];
int existencia;
float precio;
};
struct nodo
{
struct productos dato;
struct nodo *proximo;
};/* Declaracion de funciones */
void archivo(FILE *fp);
struct nodo *nuevonodo();
struct nodo *creapila(struct nodo *pri, struct productos x);
void muestra(struct nodo *pri, FILE *fp);
void main()
{ struct productos x;
struct nodo *pri=NULL;
FILE *fp;
char opcion; float auxiliar=0;
if((fp=fopen("C:\\Datos.txt","wb"))==NULL)
{
getch();
}
fseek(fp,0,2);
do
{fflush(stdin);
printf("Ingrese el Codigo de Producto ");

scanf("%d",&x.codigo);
fflush(stdin);
printf("Ingrese Nombre de Producto ");
gets(x.nombre);
fflush(stdin);
printf("Ingrese la Existencia ");
scanf("%d",&x.existencia);
fflush(stdin);
printf("Ingrese el Precio ");
scanf("%f",&auxiliar); x.precio=auxiliar;
pri=creapila(pri,x);
fflush(stdin);
printf("Desea Ingresar otro Registro? (S/N) ");
scanf("%c",&opcion); opcion=toupper(opcion);
} while(opcion=='S');
muestra(pri,fp);
fflush(stdin);
printf("El contenido de la Pila se ha Guardado. Desea Visualizarlo? (S/N)");
scanf("%c",&opcion); opcion=toupper(opcion);
if(opcion=='S') archivo(fp);
getch();
fclose(fp);
}
struct nodo *creapila(struct nodo *pri, struct productos x)
{
struct nodo *p;
p=nuevonodo();
(*p).dato=x;
(*p).proximo=pri;
return p;
}

10

struct nodo *nuevonodo()

{
struct nodo *p;
p=(struct nodo *)malloc(sizeof(struct nodo));
if(p==NULL)
{
printf("Memoria RAM Llena");
getch();
exit(0);
}
return p;
}

void muestra(struct nodo *pri, FILE *fp)

{
clrscr();
struct nodo *aux;
while(pri!=NULL)
{
printf("Codigo: %d \n",(*pri).dato.codigo);
printf("Nombre: %s \n",(*pri).dato.nombre);
printf("Existencia: %d \n",(*pri).dato.existencia);
printf("Precio: %0.2f \n\n",(*pri).dato.precio);
fwrite(&pri->dato,sizeof(struct productos),1,fp);
aux=pri;
pri=(*pri).proximo;
free(aux);
}
}
void archivo(FILE *fp)

11

{
struct productos x;
clrscr();
printf("Datos del Archivo:\n\n");
fread(&x,sizeof(struct productos),1,fp);
while(!feof(fp))
{

printf("Codigo: %d \n",x.codigo);
printf("Nombre: %s \n",x.nombre);
printf("Existencia: %d \n",x.existencia);
printf("Precio: %0.2f \n\n",x.precio);
fread(&x,sizeof(struct productos),1,fp);

}
printf("Fin de Archivo");
}

EJEMPLO 2: Pila que almacene artculos deportivos

public class ProgramaPilaArticulosDeportivos {
public static void main(String[] args) {
IntefazArticulosDeportivos interfazArticulosDeportivos;
DatosArticulosDeportivos datosArticulosDeportivos;
Pila pila;
int numero;
String menu;
String nombre;
int opcion;
interfazArticulosDeportivos = new IntefazArticulosDeportivos();
datosArticulosDeportivos = new DatosArticulosDeportivos();
numero = Integer.parseInt(JOptionPane.showInputDialog("Nmero mximo de Articulos Deportivos en la Pila : "));
pila = new Pila(numero);
opcion = 0;
nombre = "";
menu = "";
menu = menu + "1. Incluir articulo deportivo en la pila\n";
menu = menu + "2. Quitar el ltimo articulo deportivo agregado\n";
menu = menu + "3. Mostrar arreglo de articulos deportivos\n";
menu = menu + "4. Contar articulos deportivos en la pila\n";
menu = menu + "5. Recuperar articulo por numero de orden\n";
menu = menu + "6. Recuperar el ultimo articulo borrado\n";
menu = menu + "7. Ordenar por el Mayor precio\n";
menu = menu + "8. Ordenar por la Mayor unidad\n";

12

menu = menu
menu = menu
menu = menu
menu = menu
menu = menu
menu = menu
menu = menu

+ "9. Ordenar por nombre del producto\n";

+ "10. Sacar un articulo\n";
+ "11. Contar ArticulosBorrados\n";
+ "12. Encontrar el Precio ms Bajo\n";
+ "13. Encontrar La Unidad ms Baja\n";
+ "14. Encontrar un Articulo por Nombre\n";
+ "15. Salir\n";

do{

opcion = Integer.parseInt(JOptionPane.showInputDialog (menu));

switch (opcion){
case 1 : {
numero = Integer.parseInt(JOptionPane.showInputDialog("Numero de Articulo Deportivo a Incluir en la
Pila : "));
pila.incluirArticulo(datosArticulosDeportivos.cargarArticuloDeportivo(numero));
break;
}
case 2 : {
if (pila.tope < 0){
JOptionPane.showMessageDialog(null, "La pila esta vacia");
}else{
interfazArticulosDeportivos.presentarArticulosDeportivos(pila.quitarArticulo());
JOptionPane.showMessageDialog(null, "Se borro el ultimo elemento, pero se \n" +
"guardo en otra Pila");
break;
}
}
case 3 : {
interfazArticulosDeportivos.ImprimePila(pila);
break;
}
case 4 : {
JOptionPane.showMessageDialog(null, "La Pila tiene " + (pila.tope + 1) + "/" + pila.vectorpila.length+ " articulos
deportivos");
break;
}
case 5 : {
numero = Integer.parseInt(JOptionPane.showInputDialog("Nmero del Articulo a recuperar : "));
interfazArticulosDeportivos.presentarArticulosDeportivos(pila.recuperarArticuloPrueba(numero));
break;
}
case 6 : {
pila.incluirArticulo(pila.recuperarArticuloBorrado());
JOptionPane.showMessageDialog(null, "Recuperando");
break;
}
case 7 : {
pila.OrdenarMayorPrecio();
break;
}
case 8 : {

13

pila.OrdenarMayorUnidad();
break;
}
case 9 : {
pila.OrdenarNombreProducto();
break;
}
case 10 : {
pila.quitarArticulosPorNombre(Integer.parseInt(JOptionPane.showInputDialog("Nmero a quitar")));
break;
}
case 11 : {
JOptionPane.showMessageDialog(null, "La lista tiene "+ pila.verCantidadborrada()+" Articulos deportivos");
break;
}
case 12 : {
interfazArticulosDeportivos.presentarArticulosDeportivos(pila.MenorPrecio());
break;
}
case 13 : {
interfazArticulosDeportivos.presentarArticulosDeportivos(pila.MenorUnidad());
break;
}
case 14 : {
nombre = JOptionPane.showInputDialog("Nombre del Articulo a recuperar : ");
interfazArticulosDeportivos.presentarArticulosDeportivos(pila.NombreProducto());
break;
}
}
} while ((opcion >= 1) && (opcion <= 14));
}

14

EJEMPLO 3: Programa Para Control De Reserva de Aviones

#include <iostream>
#include <conio.h>
#include <stdlib.h>
//
//
//
//

codigos
asiento vacio = 0
asiento reservado = 1
asiento confirmado = 2

using namespace std;

int main()
{
int av=0,c=0,asiento=0,m=0,av1[49],av2[49],av3[49],i;
char opcion;
for (i=0;i<49;i++)
av1[i]=0;
for (i=0;i<49;i++)
av2[i]=0;
for (i=0;i<49;i++)
av3[i]=0;
cout<<"TODOS LOS ASIENTOS ESTAN DISPONIBLES....";
getch();
do
{

system("cls");
cout<<"\n\n\t Seleccione Una Opcion Del Menu\n";
cout<<"\n\n\t 1. Reservar\n";
cout<<"\n\n\t 2. Confirmar Reserva\n";
cout<<"\n\n\t 3. Cancelar Reserva\n";
cout<<"\n\n\t 4. Estado del Avion\n";
cout<<"\n\n\t 5. Salir\n";
cout<<"\nIntroduzca el Numero de la Opcion:";
cin>>opcion;
switch(opcion)

15

{
case '1':
cout<<"\nDesea Vijar En:""\n""Avion 1""\n""Avion 2""\n""Avion 3""\n""Eliga el
Numero Correspondiente al Avion Deseado: ";
cin>>av;
cout<<"\nEn que Clase Desea Viajar: ""\n""1-Primera Clase""\n""2-Segunda
Clase\n";
cin>>c;
if (c==1)
{
do {
cout<<"\nIntodusca Un Numero De Asiento Entre 0 y 14: ";
cin>>asiento;
if ((asiento<0)||(asiento>14))
cout<<"\n Dato De Asiento No Valido....";
} while ((asiento<0)||(asiento>14));
}
else
{cout<<"Elija Un Asiento Entre 15 y 49:";
do {
cout<<"\nIntroduzca El Numero De Asiento: ";
cin>>asiento;
if ((asiento<15)||(asiento>49))
cout<<"\nDato De Asiento No Valido....";
} while ((asiento<15)||(asiento>49));
}
if (av==1)
{ if (av1[asiento]==0)
{av1[asiento]=1;
cout<<"su operacion se realizo con exito...";
}
else
cout<<"El Asiento No Esta Disponible....";
}

16

if(av==2)
{ if (av2[av==2]==0)
{av2[asiento]=1;
cout<<"su operacion se realizo con exito...";
}
else
cout<<"El Asiento No Esta Disponible....";
}
if(av==3)
{ if (av3[av==3]==0)
{av3[asiento]=1;
cout<<"su operacion se realizo con exito...";
}
else
cout<<"El Asiento No Esta Disponible....";
}
break;
case '2':
Reservo:";

cout<<"\nPara Confirmar Su Reserva:""\n""Ingrese El Numero De Avion En Que

cin>>av;
cout<<"\nIngrese El Numero De Asiento:";
cin>>asiento;
if (av==1)
{ if (av1[asiento]==1)
{av1[asiento]=2;
cout<<"su confirmacion se realizo con exito...";
}
else
cout<<"El Asiento No Ha Sido Reservado Aun Por Favor Reservelo Antes....";
}
if(av==2)
{ if (av2[av==2]==1)

17

{av2[asiento]=2;
cout<<"su confirmacion se realizo con exito...";
}
else
cout<<"El Asiento No Ha Sido Reservado Aun por Favor Reservelo Antes....";
}
if(av==3)
{ if (av3[av==3]==1)
{av3[asiento]=2;
cout<<"su confirmacion se realizo con exito...";
}
else
cout<<"El Asiento No Ha Sido Reservado Aun por Favor Reservelo Antes....";
}
break;
case '3':
cout<<"\nPara Cancelar Su Reserva:""\n""Ingrese El Numero De Avion En Que

Reservo:";

cin>>av;
cout<<"\nIngrese El Numero De Asiento:";
cin>>asiento;
if (av==1)
{if (av1[asiento]==0)
cout<<"\nEl Asiento No Ha Sido Reservado Aun Por Favor Reservelo Antes....";
{if (av1[asiento]==2)
cout<<"El Asiento Ya No Se Puede Cancelar Gracias....";
else
{if (av1[asiento]==1)
av1[asiento]=0;
cout<<"\nSu Reserva Ha Sido Cancelada.";
}
}
}

18

if(av==2)
{ if (av2[av==2]==2)
av2[asiento]=0;
else
cout<<"El Asiento Ya No Se Puede Cancelar Gracias....";
}
if(av==3)
{ if (av3[av==3]==2)
av3[asiento]=0;
else
cout<<"El Asiento Ya No Se Puede Cancelar Gracias....";
}
break;
case '4':
cout<<"\nQue avion Desea Verificar Avion 1, Avion 2 o Avion 3:";
cin>>av;
cout<< "\nQue Desea Veriaficar:""\n""1-Reservas""\n""2-Reservas
Confirmadas""\n""3-Asientos Vacios""\n""Eliga La Opcion a Verificaar: ";
cin>>m;
if ((av==1)&&(m==1))
{ cout<<"Los Asientos Reservados Son: \n";
for (i=0;i<=49;i++)
{ if(av1[i]==1)
cout<<i<<"-"; }
}
else
if ((av==1)&&(m==2))
{ cout<<"Los Asientos Confirmados Son: \n";
for (i=0;i<=49;i++)
{ if(av1[i]==2)
cout<<i<<"-"; }
}
else

19

if ((av==1)&&(m==3))
{ cout<<"Los Asientos Vacios Son: \n";
for (i=0;i<=49;i++)
{ if(av1[i]==0)
cout<<i<<"-"; }
}
if ((av==2)&&(m==1))
{ cout<<"Los Asientos Reservados Son: \n";
for (i=0;i<=49;i++)
{ if(av2[i]==1)
cout<<i<<"-"; }
}
else
if ((av==2)&&(m==2))
{ cout<<"Los Asientos Confirmados Son: \n";
for (i=0;i<=49;i++)
{ if(av2[i]==2)
cout<<i<<"-"; }
}
else
if ((av==2)&&(m==3))
{ cout<<"Los Asientos Vacios Son: \n";
for (i=0;i<=49;i++)
{ if(av2[i]==0)
cout<<i<<"-"; }
}

if ((av==3)&&(m==1))
{ cout<<"Los Asientos Reservados Son: \n";
for (i=0;i<=49;i++)
{ if(av3[i]==1)
cout<<i<<"-"; }

20

}
else
if ((av==3)&&(m==2))
{ cout<<"Los Asientos Confirmados Son: \n";
for (i=0;i<=49;i++)
{ if(av3[i]==2)
cout<<i<<"-"; }
}
else
if ((av==3)&&(m==3))
{ cout<<"Los Asientos Vacios Son: \n";
for (i=0;i<=49;i++)
{ if(av3[i]==0)
cout<<i<<"-"; }
}
break;
case '5':
break;
default:
cout<<"\n

";

}
getch();
} while (opcion != '5');
cout<<"\nHa Decidido Salir Del Menu...";
getch();
return 0;
}
//</code>

21

CONCLUSION

Hemos aprendido a construir nuevos TAD para poder modelizar situaciones del mundo real. Primero,
especificando la signatura del tipo con las operaciones que se podrn aplicar y luego abordando su
implementacin. La implementacin consistir en escoger una representacin de los datos y codificar
las operaciones evaluando su coste espacial y temporal.
Por ello es importante mencionar es una lista ordenada o estructura de datos en la que el modo de
acceso a sus elementos es de tipo LIFO (del ingls Last In First Out, ltimo en entrar, primero en
salir) que permite almacenar y recuperar datos. Esta estructura se aplica en multitud de ocasiones
en el rea de informtica debido a su simplicidad y ordenacin implcita de la propia estructura. Para
el manejo de los datos se cuenta con dos operaciones bsicas: apilar (push), que coloca un objeto en
la pila, y su operacin inversa, retirar (o desapilar, pop), que retira el ltimo elemento apilado.

22

REFERENCIAS
http://cursoslibres.academica.mx/206/practicas-de
datos-basicas

programacion/estructuras-de-

http://www.uaeh.edu.mx/docencia/P_Presentaciones/icbi/asignatura/Cap3PilasColas.p
df
http://www.grycap.upv.es/gmolto/docs/eda/EDA_Tema_8_gmolto.pdf
http://decsai.ugr.es/~jfv/ed1/tedi/cdrom/docs/pilas.html
http://www.madsgroup.org/docencia/alg/pilas_colas_listas.pdf
http://www.iuma.ulpgc.es/users/jmiranda/docencia/programacion/Tema5_ne.pdf
http://www.algoritmia.net/articles.php?id=14
http://www.infor.uva.es/~belar/Ampliacion/TDAS/Utilidades_TDA_PILA.pdf
http://es.slideshare.net/nieves1988/estructura-datos-pilas-y-colas
http://www.c.conclase.net/edd/?cap=002d#2_7
http://www.programacionfacil.com/estructura_de_datos/pilas
http://computacion.cs.cinvestav.mx/~acaceres/courses/estDatosCPP /node20.html

23