Guía de Aprendizaje

El Tipo Abstracto de Datos (TAD) Pila

1. Definición:
Una Pila (Stack) es un tipo especial de lista lineal (ósea una estructura de datos), en la cual los
elementos que denominaremos NODOS se pueden APILAR o DESAPILAR (es decir, inserciones y
eliminaciones) solo por un extremo llamado cima o tope (top) de la pila. La pila es una estructura con
numerosas analogías en la vida real: una pila de pla tos, una pila de monedas, una pila de cajas
entre otras cosas.

La estructura pila se conoce también como LIFO (Last-In, First_Out), que significa “último elemento
introducido, primero elemento sacado”, es decir lo elementos solo pueden eliminarse en orden
inverso al que fueron agregados. Las pilas no son estructuras de datos fundamentales en Pascal o
Delphi, es decir, no están definidas como tales lenguajes de programación.

Debido a ello es necesario apoyarse en estructuras alternativas como los registros, los vectores e
incluso los arreglos de registros. Al utilizar arreglos para implementar pilas, tenemos la limitante de
espacio de memoria reservada. Una vez establecido un máximo de capacidad para la pila, ya no es
posible insertar más elementos.

La variable cima (también conocida como tope) contiene el valor de la cima de la pila y puede ser
utilizada como un subíndice o como un puntero al elemento superior de la pila. Si una pila no tiene
elementos, se dice que es una pila vacía. La variable o puntero cima se incrementa en uno al poner
un elemento en la pila y se decrementa en uno al quitar el elemento.

Las pilas pueden representarse de cualquiera de las tres formas que demuestra la figura inferior:

Tope AAA
Tope BBB
CCC
CCC
BBB
AAA
(a) (b)
AAA BBB CCC
Tope (c)
2. Aspectos a considerar al realizar operaciones con Pilas:
Al manipular una pila es necesario realizar algunas comprobaciones. De una pila vacía (Cima= -1) no
se pueden sacar datos ya que se produciría un desbordamiento.

Al implementar la pila utilizando una estructura de datos estática (arreglo de registros), decimos que
está llena cuando su tope sea igual a la longitud máxima del misma LONGITUD_PILA -1 y el intento
de introducir más elementos a la pila producirá un desbordamiento.

Nota: El desbordamiento producto sacar un dato de una pila vacía se denomina UnderFlow y si es
producto de agregar un elemento a una pila llena se denomina OverFlow.

3. Operaciones que desarrollaremos con Pilas en nuestra asignatura:

 Crear la Pila. (Método Constructor. Asigna el valor inicial (-1) al tope de la pila)
 Retornar cima. (Recupera el Tope de la Pila)
 Pila vacía (Determina si una pila está vacía)
 Pila llena (Determina si una pila está llena)
 Informe de Errores (Informa lo errores que se presentan al Apilar y Desapilar)
 Apilar (Push). Inserta un elemento en la cima de la pila.
 Desapilar (Pop). Recupera y elimina el último elemento en la cima de la pila.
 Retornar Elemento. (Recupera el valor que se encuentra en la cima de una pila)
 Mostrar Elementos (Retorno TODOS los valores actuales de una pila)

Visualice el siguiente diagrama UML:

Para nuestro ejercicio Crearemos tres (03) clases Pila-Operar_Pila-ProgramaPilas.

Clase Pila: Será nuestra unidad de trabajo es decir, nuestro TAD o estructura de datos pila.

El Pseudocódigo será el siguiente:

Clase Pública Pila {

Atributo protegido final entero LONGITUD_PILA=10;

Atributo protegido entero cima;
Arreglo protegido entero [ ] elementos = nuevo entero [LONGITUD_PILA];

}//fin de clase Pila

Clase Pública Operar_Pila {

Pila pila=nueva Pila();

Método Constructor Operar_Pila(){

pila.cima= -1;
}//fin de constructor

Método Publico entero retornarCima(){

retornar pila.cima;
}//fin de metodo retornarCima()

/*Este método evalúa si la cima es igual a -1 de ser así devuelve true que significa que la pila esta
vacía*/
Método Publico booleano estaVacia(){
retornar pila.cima== -1;
}//fin de metodo estaVacia()

/*Este método evalúa si la cima es igual a al valor de la LONGITUD_PILA-1 porque el índice de

nuestro arreglo de elementos comienza en cero de ser así devuelve true que significa que la pila está
llena*/
Método Publico booleano estaLlena(){
retornar pila.cima==pila.LONGITUD_PILA-1;
}//fin de metodo estaLlena()
/*Para apilar chequeamos si la pila NO ESTA LLENA usando la negación del método estaLlena() de
ser así:
1. Sumamos 1 a posición de la cima
2. Nos ubicamos en esa posición en el arreglo de elementos y le asignamos el dato recibido
como parámetro
3. Invocamos al método mostrarElementos para ir visualizando como se apila cada elemento.
4. En caso que este llene la pila invocamos el método informaEvento y le pasamos el valor 1 como
parámetro */

Método Publico nulo apilar(int dato){

Si (NO(estaLlena())){
pila.cima=retornarCima()+1;
pila.elementos[retornarCima()]=dato;
Método mostrarElementos();
}//fin de if
En caso contrario{
Método informaEvento(1);
}//fin de caso contrario

}//fin de metodo apilar()

/*Para Desapilar chequeamos si la pila NO ESTA VACIA usando la negación del método estaVacia()
de ser así:
1. Nos ubicamos en la posición de la cima en el arreglo de elementos y le asignamos el valor cero
2. Restamos 1 a posición de la cima
3. Invocamos al método mostrarElementos para ir visualizando como se desapila cada elemento.
4. En caso que este vacía la pila invocamos el método informaEvento y le pasamos el valor 2 como
parámetro */

Método Publico nulo desapilar(){

Si (NO(estaVacia())){
pila.elementos[retornarCima()]=0;
pila.cima=retornarCima()-1;
Método mostrarElementos();
}//fin de if
En caso contrario {
Método informaEvento(2);
}//fin de caso contrario
}//fin de método desapilar()
 /*Este método nos retorna el valor actual del elemento que se encuentra apilado en la cima de la
pila*/
Método Público Entero retornarElemento(){
Retornar pila.elementos[retornarCima()];
}//fin de metodo retornarCima()

/*Usaremos este método para enviar un mensaje cuando la pila este llena o vacía según el
Parámetro que recibimos de los métodos apilar o desapilar*/
Método Público Nulo informaEvento(int e){
Caso (e) {
Caso 1: Mostrar Ventana de Error con mensaje de alerta de Pila LLena;
Caso 2: Mostrar Ventana de Error con mensaje de alerta de Pila Vacía;
}//fin de Caso
}//fin de metodo informaEvento()

/*Este método recorre el arreglo desde la última posición del arreglo elementos hasta la Primera
posición. Imprime el valor del arreglo en la posición dada. Indicaremos que nos Mostrará un valor
entero con "%d" entre corchetes "[]" y seguidamente dará un salto de línea con "\n" . Al final
imprimimos 2 líneas en blanco **/

Método Público Nulo mostrarElementos(){

Mensaje en Pantalla ("Elementos en la Pila: ");
Para (Entero i = pila.LONGITUD_PILA-1; i>=0; i--){
Mensaje en Pantalla con Formato("[%d]\n", pila.elementos[i]);
}//fin de for
Mensaje en Pantalla ("");
Mensaje en Pantalla ("");
}//fin de metodo mostrarElementos()
}//fin de la clase OperaPila

Para la clase ProgramaPilas haremos lo siguiente:

1. Se programa el método principal en donde se instanciará (es decir, creará) un objeto de la

clase Operar_Pila.
2. Se instanciará un objeto que genere valores aleatorios
3. Se pasaran valores aleatorios como parámetros al método Apilar
4. Invoque el método Apilar tantas veces como posiciones tenga el arreglo de elementos de la
clase pila.
5. Intente Apilar un elemento adicional luego que la pila este llena para verificar el
funcionamiento del método informaEvento().
6. Invoque el método Desapilar tantas veces como posiciones tenga el arreglo de elementos de
la clase pila.
7. Intente Desapilar un elemento adicional luego que la pila este vacía para verificar el
funcionamiento del método informaEvento().