ESTRUCTURAS LIFO: INTEGRANTES:
1. ARANA BARRUETO,
JHOAO.
PILA DE DATOS 2.CHUNQUE SALINAS,
JOCSAN.
ALGORITMOS Y ESTRUCTURA DE DATOS
DOCENTE: VIDAL MELGAREJO, ZORAIDA YANET
Página |1
Contenido
1. DEFINICIONES Y REPRESENTACIONES ................................................................................... 2
2. OPERACIONES CON PILAS ..................................................................................................... 3
3. ELEGIR ENTRE IMPLEMENTACIÓN CON LISTAS O CON ARRAYS ........................................... 4
3.1. Implementación de una pila usando lista de posiciones: ............................................. 4
3.2. Implementación de una pila usando un array: ............................................................. 4
4. ERRORES Y OPERACIONES ..................................................................................................... 5
4.1. Algoritmo pila_vacia ...................................................................................................... 5
4.2. Algoritmo pila_llena ...................................................................................................... 5
4.3. Algoritmo PONE ............................................................................................................ 6
4.4. Algoritmo QUITA ........................................................................................................... 6
5. EJEMPLO APILAR, DESAPILAR, MOSTRAR PILA Y ELIMINAR PILA .......................................... 8
6. IMPORTANCIA ..................................................................................................................... 11
7. REFERENCIAS BIBLIOGRAFICAS ........................................................................................... 11
UNIVERSIDAD NACIONAL DE TRUJILLO
Página |2
ESTRUCTURAS LIFO: PILAS DE
DATOS
1. DEFINICIONES Y REPRESENTACIONES
Uno de los conceptos que más se emplean en las estructuras de datos lineales,
en la elaboración de programas, son las pilas. Éstas son aplicadas en cuanto a
las restricciones sobre el acceso a los datos del arreglo, ya sea para insertar o
eliminar elementos, actualizando el contenido de los registros. Iniciemos por
definir el término fundamental de una pila como “una lista de elementos en la
cual se puede insertar y eliminar elementos sólo por uno de los dos extremos.”
Para tener una comprensión más clara de lo que es una pila, imagine el acomodo
de latas de un producto X en un centro comercial. O bien el apilamiento de libros
que se amontonan de abajo hacia arriba. En principio no hay libros; después
ponemos uno, y otro encima de éste, y así sucesivamente. Posteriormente los
solemos retirar empezando desde la cima de la pila de libros, es decir, desde el
último que pusimos, y terminaríamos por retirar el primero que pusimos,
posiblemente ya cubierto de polvo. (Ver Figura 1.0)
Figura 1.0: Productos en un supermercado y libros apilados
Las pilas ofrecen dos operaciones fundamentales, que son apilar y desapilar sobre la
cima. El uso que se les dé a las pilas es independiente de su implementación interna.
Es decir, se hace un encapsulamiento. Por eso se considera a la pila como un tipo
abstracto de datos.
UNIVERSIDAD NACIONAL DE TRUJILLO
Página |3
Una pila es un contenedor de datos cuyo comportamiento está regido por el principio
LIFO (Last Input First Output). En este tipo de estructura los datos o elementos pueden
insertarse y suprimirse elementos solo por un extremo, llamado tope o cima; es decir,
en una pila el último dato en entrar es el primero en salir.
Aplicaciones de las Pilas. Los navegadores de Internet almacenan las direcciones
visitadas recientemente. Cada vez que el usuario visita una página, su dirección es
almacenada en una pila, de forma que cada vez que el usuario hace click en back se
retira el último elemento insertado en la pila, esto es, se muestra en pantalla la última
página visitada.
2. OPERACIONES CON PILAS
Básicas
interrogadores: size, isEmpty
pop(): Regresa el último elemento insertado en la pila (Borrado)
push(): inserta un elemento en el tope de la pila. (Inserción)
top: Acceso
Conversion: toArray, toPositionList
Auxiliares
llena():Regresa verdadero si la pila está llena.
vacia(): Regresa verdadero si la pila está vacía.
size(): Regresa el tope de la pila.
vaciar(): Elimina todos los elementos de la pila
A continuación, se expone la implementación de pilas mediante Arrays y mediante Listas
enlazadas. En ambos casos se cubren cuatro operaciones básicas: Inicializar, Apilar,
Desapilar, y Vacía (nos indica si la pila está vacía). Las claves que contendrán serán
simplemente números enteros, aunque esto puede cambiarse a voluntad y no supone
ningún inconveniente.
UNIVERSIDAD NACIONAL DE TRUJILLO
Página |4
3. ELEGIR ENTRE IMPLEMENTACIÓN CON LISTAS O CON ARRAYS
El uso del array es idóneo cuando se conoce de antemano el número máximo de
elementos que van a ser apilados y el compilador admite una región contigua de
memoria para el array. En otro caso sería más recomendable usar la implementación
por listas enlazadas, también si el número de elementos llegase a ser excesivamente
grande.
La implementación por array es ligeramente más rápida. En especial, es mucho más
rápido a la hora de eliminar los elementos que hayan quedado en la pila. Por lista
enlazada esto no es tan rápido. Por ejemplo, piénsese en un algoritmo que emplea una
pila y que en algunos casos al terminar éste su ejecución deja algunos elementos sobre
la pila. Si se implementa la pila mediante una lista enlazada entonces quedarían en
memoria una serie de elementos que es necesario borrar. La única manera de borrarlos
es liberar todas las posiciones de memoria que le han sido asignadas a cada elemento,
esto es, desapilar todos los elementos. En el caso de una implementación con array
esto no es necesario, salvo que quiera liberarse la región de memoria ocupada por éste.
3.1. Implementación de una pila usando lista de posiciones: Para hacer la
implementación se utiliza una lista con cabecera ficticia (ver apartado de listas).
Dado el carácter dinámico de esta implementación no existe una función que
determine si la pila está llena. Si el usuario lo desea puede implementar un análisis
del código devuelto por la función de asignación de memoria.
Solo tiene la lista como atributo:
El tamaño de la pila es el de la lista
Apilar (push) consiste en insertar al principio
Desapilar (pop) consiste en borrar el primer elemento
La consulta se realiza mediante la operación top
Tiene 4 constructores:
(1) Vacío, (2) un array, (3) una lista posiciones o (4) una pila
pop y top lanzan EmptyStackException si la pila esta vacía
push no lanza excepcion toString y toArray usan los métodos de la lista
toPositionList devuelve una copia de la lista atributo
3.2. Implementación de una pila usando un array: Esta implementación es
estática, es decir, da un tamaño máximo fijo a la pila, y si se sobrepasa dicho límite
se produce un error. La comprobación de apilado en una pila llena o desapilado en
una pila vacía no se han hecho, pero sí las funciones de comprobación, que el lector
puede modificar según las necesidades de su programa.
Establece un tamaño inicial para el array. Cuando se llena crea uno
mayor copiando los elementos (shallow copy)
Tiene 3 atributos: arr, size, defaultCapacity
El tamaño de la pila es el número de elementos apilados (size)
Apilar (push) consiste en añadir después del último elemento
Desapilar (pop) consiste en borrar el ultimo
Tiene 4 constructores:
Vacío, (2) un valor para la capacidad, (3) un array, (4) una lista de
posiciones, (5) una pila
UNIVERSIDAD NACIONAL DE TRUJILLO
Página |5
pop y top lanzan EmptyStackException si la pila está vacía
push comprueba si estamos al máximo de la capacidad y amplia si es necesario
toString escribe el array en orden inverso
toArray y toPositionList devuelven los elementos uno a uno insertándolos en el
array o en la lista
4. ERRORES Y OPERACIONES
Un error que se puede presentar es tratar de eliminar un elemento de la pila
vacía. Este tipo de error se le conoce como subdesbordamiento -underflow-
Operaciones con pilas:
Insertar un elemento -push- en la pila.
Eliminar -pop- de la pila.
Pila_vacia
Pila_llena
Considerando que se tiene una pila con una capacidad para
almacenar un numero máximo de elementos -MAX- y que el ultimo
de ellos se indica con TOPE, a continuación se presentan los
algoritmos de las operaciones mencionadas. Si la pila esta vacía,
entonces TOPE es igual a 0.
4.1. Algoritmo pila_vacia
Pila_vacia (PILA,TOPE,BAND)
Este algoritmo verifica si una estructura tipo pila-PILA-esta vacía, asignando a BAND el
valor de verdad correspondiente. La pila se implementa en un arreglo unidimensional.
TOPE es un parámetro de tipo entero. BAND es un parámetro de tipo booleano.
1. Si (TOPE=0) {Verifica si no hay elementos almacenados en la pila}
Entonces
Hacer BAND <- VERDADERO {La pila esta vacía}
Sino
Hacer BAND <- FALSO {La pila no está vacía}
2. (Fin del condicional del paso 1)
4.2. Algoritmo pila_llena
Pila_llena (PILA, TOPE, MAX, BAND)
Este algoritmo verifica si una estructura tipo pila está llena asignando a BAND el de
verdad correspondiente. La pila se implementa en un arreglo unidimensional de más
elementos. TOPE es un parámetro de tipo entero. BAND es un parámetro de tipo
booleano.
1. Si (TOPE = MAX)
UNIVERSIDAD NACIONAL DE TRUJILLO
Página |6
Entonces
Hacer BAND <- VERDADERO (LA PILA ESTA LLENA)
Si no
Hacer BAND <- FALSO (LA PILA NO ESTA LLENA)
2. Fin del condicional del paso 1
4.3. Algoritmo PONE
Pone (PILA, TOPE, MAX, DATO)
Este algoritmo agrega el elemento DATO en una estructura tipo pila-PILA-, si la misma
no está llena. Actualiza el valor de TOPE. MAX representa el número máximo de
elementos que se puede almacenar PILA. TOPE es un parámetro de tipo entero.
1. Llamar a Pila_llena con PILA, TOPE, MAX y BAND
2. Si (BAND = VERDADERO)
Entonces
Escribir “desbordamiento – Pila llena”
Si no
Hacer TOPE <- TOPE + 1 y PILA[TOPE] <- DATO
{Actualiza TOPE e inserta el nuevo elemento en el TOPE de la PILA}
3. (Fin del condicional paso 2)
4.4. Algoritmo QUITA
Quita (PILA, TOPE, DATO)
Este algoritmo saca un elemento DATO en una estructura tipo pila-PILA-, si esta se
encuentra vacía. El elemento que se elimina es el que se encuentra en la posición
indicada por TOPE.
1. Llamar a Pila_vacia con PILA, TOPE y BAND
2. Si (BAND = VERDADERO)
Entonces
Escribir “Subdesbordamiento – Pila vacía”
Si no
Hacer DATO <- PILA[TOPE] y TOPE <- TOPE - 1
{Actualiza TOPE }
3. (Fin del condicional paso 2)
UNIVERSIDAD NACIONAL DE TRUJILLO
Página |7
Ejemplo días de la semana
UNIVERSIDAD NACIONAL DE TRUJILLO
Página |8
5. EJEMPLO APILAR, DESAPILAR, MOSTRAR PILA Y ELIMINAR
PILA
#include
<iostream>
using namespace std;
struct nodo{
int nro;
struct nodo *sgte;
};
typedef nodo *ptrPila; // creando nodo tipo puntero( tipo de dato )
/* Apilar elemento
------------------------------------------------------------------------*/
void push( ptrPila &p, int valor )
{
ptrPila aux;
aux = new(struct nodo); // apuntamos al nuevo nodo creado
aux->nro = valor;
aux->sgte = p ;
p = aux ;
}
/* Desapilar elemento (devuelve elemento)
------------------------------------------------------------------------*/
int pop( ptrPila &p )
{
int num ;
ptrPila aux;
aux = p ;
num = aux->nro; // asignamos el primer vamor de la pila
p = aux->sgte ;
delete(aux);
return num;
}
/* Muestra elementos de la pila
------------------------------------------------------------------------*/
void mostrar_pila( ptrPila p )
UNIVERSIDAD NACIONAL DE TRUJILLO
Página |9
{
ptrPila aux;
aux = p; // apunta al inicio de la lista
while( aux !=NULL )
{
cout<<"\t"<< aux->nro <<endl;
aux = aux->sgte;
}
}
/* Eliminar todos los elementos de la pila
------------------------------------------------------------------------*/
void destruir_pila( ptrPila &p)
{
ptrPila aux;
while( p != NULL)
{
aux = p;
p = aux->sgte;
delete(aux);
}
}
/* Menu de opciones
------------------------------------------------------------------------*/
void menu()
{
cout<<"\n\t IMPLEMENTACION DE PILAS EN C++\n\n";
cout<<" 1. APILAR "<<endl;
cout<<" 2. DESAPILAR "<<endl;
cout<<" 3. MOSTRAR PILA "<<endl;
cout<<" 4. DESTRUIR PILA "<<endl;
cout<<" 5. SALIR "<<endl;
cout<<"\n INGRESE OPCION: ";
}
/* Funcion Principal
------------------------------------------------------------------------*/
int main()
{
ptrPila p = NULL; // creando pila
int dato;
int op;
UNIVERSIDAD NACIONAL DE TRUJILLO
P á g i n a | 10
int x ; // numero que devuelve la funcon pop
system("color 0b");
do
{
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");
UNIVERSIDAD NACIONAL DE TRUJILLO
P á g i n a | 11
}while(op!=5);
return 0;
}
6. IMPORTANCIA
Finalmente podemos concluir que las pilas son necesarias en este tipo de
aplicaciones por lo siguiente:
Permiten guardar la dirección del programa, o subprograma, desde
donde se hizo la llamada a otros subprogramas, para regresar
posteriormente y seguir ejecutándolo a partir de la instrucción
inmediata a la llamada.
Permiten guardar el estado de las variables en el momento en que
se hace la llamada, para seguir ocupándolas al regresar del
subprograma.
7. REFERENCIAS BIBLIOGRAFICAS
https://universidad-une.com/contenido/7ba410e7f_archivo_guia_estudio.pdf
https://www.uaeh.edu.mx/docencia/P_Presentaciones/icbi/asignatura/Cap3PilasColas.
pdf
http://www.cartagena99.com/recursos/alumnos/apuntes/AED_fifo_lifo.pdf
http://www.utm.mx/~caff/doc/Notas%20de%20Estructura%20de%20datos.pdf
http://robotica.uv.es/pub/Libro/PDFs/CAPI5.pdf
http://www.iuma.ulpgc.es/users/jmiranda/docencia/programacion/Tema4_ne.pdf
http://fcqi.tij.uabc.mx/usuarios/palacios/Unidad%20III%20Pilas%20y%20Colas.pdf
http://www.algoritmia.net/articles.php?id=14
https://www.programacion.com.py/escritorio/c/pilas-en-c
http://blog.martincruz.me/2012/10/pilas-en-c.html
http://repositori.uji.es/xmlui/bitstream/handle/10234/119886/tema5.pdf?sequence=1
UNIVERSIDAD NACIONAL DE TRUJILLO
P á g i n a | 12
https://books.google.com.pe/books?id=8OBlquzq83oC&pg=PA31&lpg=PA31&dq=ERR
ORES+Y+OPERACIONES+CON+PILAS&source=bl&ots=M42MNU0XLU&sig=d9gH0r
6iC4vwa507MCpmMtj-2rE&hl=es-
419&sa=X&ved=0ahUKEwiog66qqIPYAhUsleAKHae8COMQ6AEIPjAE#v=onepage&q
=ERRORES%20Y%20OPERACIONES%20CON%20PILAS&f=false
UNIVERSIDAD NACIONAL DE TRUJILLO
