PILAS a) INSERCIÓN EN UNA PILA VACIA

Partiremos de que ya tenemos el nodo a insertar y, por supuesto un puntero que apunte
DEFINICIÓN. a él, además el puntero de la Pila valdrá NULO:
La estructura de datos PILA consiste en una colección lineal
(horizontal o verticas o como quiera representarlo). Sin El proceso es muy simple, bastará con que:
embargo, la principal característica de una pila es cómo se 1. nodo.siguiente apunte a NULO.
insertan y eliminan los datos. Las pilas tienen un
comportamiento LIFO (Last In First Out - último en entrar, 2. Pila apunte a nodo.
primero en salir), en el que los elementos se "saltan" se
recuperan y eliminan del más reciente al más antiguo.
Ejemplo de este tipo de etructura es una pila de platos. Sólo
es posible agregar platos en la parte superior de la pila, y sólo b) INSERCIÓN EN UNA PILA NO VACIA
pueden tomarse del mismo extremo. Podemos considerar el caso anterior como un caso particular de éste, la única diferencia
es que podemos y debemos trabajar con una pila vacía como con una pila normal.
De nuevo partiremos de un nodo a insertar, con un puntero que apunte a él, y de una
pila, en este caso no vacía:

En una pila es muy importante que nuestro programa

nunca pierda el valor del puntero al primer elemento.
Teniendo en cuenta que las inserciones y borrados en
una pila se hacen siempre en un extremo, lo que El proceso sigue siendo muy sencillo:
consideramos como el primer elemento de la Pila es en realidad el último elemento de 1. Hacemos que nodo.siguiente apunte a Pila.
la pila.
2. Hacemos que Pila apunte a nodo.
OPERACIONES BÁSICAS CON PILAS
Las pilas sólo permiten las operaciones de “push” y “pop”:
➢ Push (Insertar): Agregar un elemento al final de la pila.
➢ Pop (Eliminar): Leer y eliminar un elemento del final de la pila.
ELIMINACIÓN EN UNA PILA
INSERCIÓN DE ELEMENTOS EN LA PILA PUSH() Ahora sólo existe un caso posible, ya que sólo podemos leer desde un extremo de la pila
(Tope). Partiremos de una pila con uno o más nodos, y usaremos un puntero auxiliar,
Las operaciones con pilas son muy simples, no hay casos especiales, salvo que la Pila nodo:
esté vacía.
1. Hacemos que nodo apunte al primer elemento de la pila, es decir a Pila.
2. Asignamos a Pila la dirección del segundo nodo de la pila: Pila.siguiente.

1 / 1/1 1/2
 3. Guardamos el contenido del nodo para devolverlo como retorno, recuerda public void setSiguiente(Nodo siguiente) {
que la operación pop equivale a leer y borrar. this.siguiente = siguiente;
}
4. Liberamos la memoria asignada al primer nodo, el que queremos eliminar.
}
********** CLASE Pila.java **********
public class Pila {
private Nodo inicio; // Puntero, indica el inicio de la pila, también conocida como el TOPE de la pila.
private int tamanio; // Variable para registrar el tamaño de la pila.

Si la pila sólo tiene un nodo, el proceso sigue siendo válido, ya que el valor de // Constructor por defecto.
Pila.siguiente es NULO, y después de eliminar el último nodo la pila quedará vacía, y el
valor de Pila será NULO. public void Pila() {
inicio = null;
EJEMPLO DE MANEJO DE PILAS EN JAVA tamanio = 0;
En el siguiente ejemplo se muestra el manejo de una pila que almacena un dato de }
tipo entero.
/*Consulta si la pila es vacia, retorna true si es primer nodo (inicio) no apunta a otro */
********** CLASE Nodo.java **********
public boolean esVacia(){
public class Nodo {
return inicio == null;
private int valor; // Variable en la cual se va a guardar el valor.
private Nodo siguiente; // Variable para enlazar los nodos. }
/** Consulta cuantos elementos (nodos) tiene la pila. */
/** Constructor en el que inicializamos el valor de las variables. */
public void Nodo(){ public int getTamanio(){
this.valor = 0; return tamanio;
this.siguiente = null; }
} /** Agrega un nuevo nodo a la pila. parametro valor a agregar. */
// Métodos get y set para los atributos. public void apilar(int valor){
Nodo nuevo = new Nodo(); // Define un nuevo nodo.
public int getValor() { nuevo.setValor(valor); // Agrega al valor al nodo.
return valor;
// Consulta si la pila esta vacia.
}
if (esVacia()) {
public void setValor(int valor) { // Inicializa la pila con el nuevo valor.
this.valor = valor; inicio = nuevo;
} }
public Nodo getSiguiente() {
return siguiente; // Caso contrario agrega el nuevo nodo al inicio de la pila.
} else{
2 / 1/1 2/2
 nuevo.setSiguiente(inicio); // Compara si el valor del nodo es igual que el de la referencia.
inicio = nuevo; if (referencia == aux.getValor()) {
} // Cambia el valor de la bandera.

// Incrementa el contador del tamaño. existe = true;

tamanio++; }
} else{
// Avanza al siguiente nodo.
/** Elimina el elemento que se encuentra en el tope de la pila. */
public void retirar() { aux = aux.getSiguiente();
if (!esVacia()) { }
// Asigna como primer nodo al siguiente de la pila. }
inicio = inicio.getSiguiente(); // Retorna el valor de la bandera.
return existe;
// Decrementa el contador del tamaño de la pila }
tamanio--;
} /** Elimina nodo de pila por su valor. parametro referencia valor de referencia para ubicar el nodo. */
} public void remover(int referencia){
/* Consulta valor del nodo en la cima de la pila. retorna valor de nodo. */ // Consulta si el valor existe en la pila.
if (buscar(referencia)) {
public int cima() throws Exception{
if(!esVacia()){ // Crea una pila auxiliar para guardar los valores que se vayan desapilando de la pila original.

return inicio.getValor(); Nodo pilaAux = null;

} else { // Recorre la pila hasta llegar al nodo que tenga el valor igual que el de referencia.
throw new Exception("La pila se encuentra vacia."); while(referencia != inicio.getValor()) {
}
// Crea un nodo temporal para agregarlos a la pila auxiliar.
} Nodo temp = new Nodo();
/** Busca elemento en pila. Parametro valor del nodo a buscar. retorna TRUE si valor referencia existe en
// Ingresa el valor al nodo temporal.
pila. */
temp.setValor(inicio.getValor());
public boolean buscar(int referencia){
// Crea una copia de la pila. // Consulta si la pila auxiliar no a sido inicializada.
Nodo aux = inicio; if(pilaAux == null){

// Bandera para verificar si existe el elemento a buscar. // Inicializa la pila auxiliar.

boolean existe = false; pilaAux = temp;
}
// Recorre pila hasta encontrar el nodo o llegar al final de la pila.
while(existe != true && aux != null){ // Caso contrario si la pila auxiliar ya contiene elementos los agrega al inicio.
else{

3 / 1/1 3/2
 temp.setSiguiente(pilaAux); // Consulta si la pila auxiliar no a sido inicializada.
pilaAux = temp; if(pilaAux == null){
} // Inicializa la pila auxiliar.
// Elimina el nodo del tope de la pila hasta llegar al nodo que se desea eliminar. pilaAux = temp;
retirar(); }
} // Caso contrario si la pila auxiliar ya contiene elementos los agrega al inicio.
// Elimina el nodo que coincide con el de referencia. else{
retirar(); temp.setSiguiente(pilaAux);
pilaAux = temp;
// Regresa valores de pila auxiliar a pila original mientras pila auxiliar tenga elementos.
}
while(pilaAux != null) {
// Elimina el nodo del tope de la pila hasta llegar al nodo que se desea eliminar.
// Utiliza el metodo apilar para regresar los elementos a la pila original.
retirar();
apilar(pilaAux.getValor());
}
// Avansa al siguiente nodo de la pila auxiliar.
// Actualiza el valor del nodo.
pilaAux = pilaAux.getSiguiente();
inicio.setValor(valor);
}
//Regresa valores de pila auxiliar a pila original mientras pila auxiliar tenga elementos.
// Libera la memoria utilizada por la pila auxiliar.
while(pilaAux != null) {
pilaAux = null;
} // Utiliza el metodo apilar para regresar los elementos a la pila original.
} apilar(pilaAux.getValor());
/* Actualiza valor de nodo en pila. parametro referencia valor del nodo para ubicar el que se actualizará. // Avansa al siguiente nodo de la pila auxiliar.
parametro valor que remplazará el valor del nodo. */ pilaAux = pilaAux.getSiguiente();
public void editar(int referencia, int valor) { }
// Consulta si el nodo existe en la pila
if (buscar(referencia)) { // Libera la memoria utilizada por la pila auxiliar.
pilaAux = null;
// Crea una pila auxiliar. }
Nodo pilaAux = null; }
// Recoore la pila hasta llegar al nodo que tenga el valor igual que el de referencia. /** Elimina la pila */
while(referencia != inicio.getValor()){ public void eliminar(){
// Crea un nodo temporal para agregarlos a la pila auxiliar. // Elimina el valor y la referencia a los demas nodos.
Nodo temp = new Nodo(); inicio = null;
// Ingresa el valor al nodo temporal.
tamanio = 0; // Reinicia el contador a 0.
temp.setValor(inicio.getValor());
}

4 / 1/1 4/2
 op=lee.nextInt();
/** Despliega en pantalla los elementos de la pìla. */
public void listar(){ switch (op) {
Nodo aux = inicio;
// Recorre la pila hasta el ultimo nodo. case 1:
while(aux != null){ System.out.println("Dato a introducir: ");
System.out.println("|\t" + aux.getValor() + "\t|"); dato=lee.nextInt();
System.out.println("-----------------"); pila.apilar(dato);
aux = aux.getSiguiente(); break;
} case 2:
} pila.retirar();
} break;
case 3:
********** CLASE Main.java ********** int busca, inserta;
import java.util.Scanner; System.out.println("Dato a buscar---> ");
busca=lee.nextInt();
public class Main { System.out.println("Dato a insertar---> ");
public static void main(String[] args) { inserta=lee.nextInt();
Pila pila = new Pila(); pila.editar(busca, inserta);
int dato; break;
Scanner lee = new Scanner(System.in); case 4:
System.out.println("<<-- Ejemplo de Pila -->>\n\n"); System.out.println("Dato a eliminar ---> ");
int op=0; busca=lee.nextInt();
do { pila.remover(busca);
System.out.println("Tamaño de la PILA----> "+pila.getTamanio()); break;
System.out.println("<<-- MENU DE OPCIONES -->>\n\n"); case 5:
System.out.println("1. Insertar dato en la PILA.\n" System.out.println("Dato a buscar---> ");
+ " 2. Eliminar de la PILA (Tope).\n" busca=lee.nextInt();
+ " 3. Modificar el valor de un NODO\n" System.out.println(pila.buscar(busca));
+ " 4. Eliminar NODO con un valor específico\n" break;
+ " 5. Buscar un valor en la PILA\n" case 6:
+ " 6. Eliminar la PILA.\n" pila.eliminar();
+ " 7. Verificar PILA vacia\n" break;
+ " 8. Mostrar PILA\n" case 7:
+ " 0. Salir\n"); System.out.println(pila.esVacia());
System.out.print("Número de opción---> "); break;
5 / 1/1 5/2
 case 8: • Utilizando un list para crear una pila Python
System.out.println("<<<<<< IMPRIMIENDO PILA >>>>>>"); La implementación más sencilla de la PILA en Python utiliza la función
System.out.println("Tamaño: "+pila.getTamanio()); incorporada lista tipo. En el ejemplo siguiente, en lugar de push() se utiliza la
pila.listar(); función append para añadir elementos a la pila. La dirección POP elimina elementos de
break; la PILA.
}
EJEMPLO
}while (op!=0);
} # Creating a stack as a blank list.
} example_stack = []

APLICACIONES DE LAS PILAS # Pushing elements to the stack using the append method.
Con la implementación de las pilas es posible el uso de la modularización (recursividad). example_stack.append("First Item")
La variable que llama al mismo procedimiento en el que está, habrá que guardarla así example_stack.append("Second Item")
como el resto de variables de la nueva llamada, para a la vuelta de la recursividad ir example_stack.append("Third Item")
sacándolas, esto es posible a la implementación de pilas.
Las pilas también se utilizan en muchas aplicaciones que utilizamos con frecuencia. Por # Poping an element from the stack using the pop method.
ejemplo, la gestión de ventanas en Windows (cuando cerramos una ventana siempre popped_item = example_stack.pop()
recuperamos la que teníamos detrás). Otro ejemplo es la evaluación general de
cualquier expresión matemática para evitar tener que calcular el número de variables # Displaying the results
temporales que hacen falta. print("The stack now contains: " + ", ".join(example_stack) + ".")
print("The popped item is: " + popped_item + ".")
Por ejemplo:
3 + 4 * (8 – 2 * 5) El uso del tipo lista para pilas en Python tiene dos inconvenientes:
• La lista de Python no fue diseñada para trabajar como una pila, y no almacena
elementos y recupera elementos eficientemente. Esto puede hacer que las
operaciones de pila sean a veces más lentas de lo esperado.
Cómo implementar una pila en Python
Hay varias formas de implementar la estructura PILA en Python. Cada una de las • Python incluye numerosos métodos para listas que, si se utilizaran, socavarían el
siguientes tres secciones muestra una forma diferente de hacerlo, cada una usando un correcto funcionamiento de tus pilas. Por ejemplo insert método. Permite añadir
módulo Python diferente. A lo largo del camino, también puedes ver lo que diferencia a un elemento a una lista en un índice específico. El uso de este método en una lista
cada método, para ayudarte a decidir entre ellos. que funciona como una pila podría causar problemas significativos.
Cada una de estas secciones incluye código. Estos bloques de código se dividen en tres Dicho esto, las listas aún pueden soportar bien las pilas de Python para la mayoría de las
operaciones esenciales para trabajar con pilas: necesidades.
• Creación de la pila inicial
• Push, añadir elementos al final de la pila
• Pop, quitar y devolver elementos del final de la pila
6 / 1/1 6/2
 • Usando collections.deque para crear una pila Python Usando queue.LifoQueue para crear una pila Python
Las instalaciones de Python vienen con un collections por defecto. Este módulo
Otro módulo que viene con las instalaciones de Python es queueque
incluye dequeque es una excelente herramienta para crear y gestionar pilas en
incluye LifoQueue para pilas seguras. El uso de la LifoQueue sigue la misma estructura
Python. deque se pronuncia "deck" y significa "cola doble". Como se demuestra en el
que el deque arriba. Sin embargo, tenga en cuenta que LifoQueue utiliza put en lugar
ejemplo de la lista anterior, puede utilizar la misma append y pop funciones sobre
de append y get en lugar de pop.
deque.
# Importing LifoQue.
# Importing deque.
from queue import LifoQueue
from collections import deque

# Creating a blank stack using LifoQueue.

# Creating a blank stack using deque.
example_stack = LifoQueue()
example_stack = deque()

# Pushing elements to the stack using the put method.

# Pushing elements to the stack using the append method.
example_stack.put("First Item")
example_stack.append("First Item")
example_stack.put("Second Item")
example_stack.append("Second Item")
example_stack.put("Third Item")
example_stack.append("Third Item")

# Poping an element from the stack using the pop method.

# Poping an element from the stack using the pop method.
popped_item = example_stack.get()
popped_item = example_stack.pop()

# Displaying the results

# Displaying the results
print("The stack now contains: " + ", ".join(example_stack.queue) + ".")
print("The stack now contains: " + ", ".join(example_stack) + ".")
print("The popped item is: " + popped_item + ".")
print("The popped item is: " + popped_item + ".")

Este ejemplo sólo difiere del ejemplo de la lista en las dos primeras líneas: el requisito La principal razón para utilizar LifoQueue es su seguridad. Las listas no son seguras para
de importar deque y el uso del deque para iniciar la pila. los hilos, y aunque la función append y pop métodos para deque puede ser, deque en
su conjunto no lo es. Por lo tanto, si necesita implementar una pila en un entorno
Los símbolos deque está pensada para trabajar específicamente con la estructura de multihilo, debería optar por LifoQueue sobre las otras dos opciones.
datos de la pila. deque almacena los elementos de forma más coherente al realizar
operaciones en la pila. También evita los métodos de lista relacionados con índices, que
pueden alterar el funcionamiento de una pila. Esto es especialmente útil en un entorno
de equipo, donde las restricciones estrictas pueden ayudar a garantizar un uso
coherente entre los desarrolladores.

7 / 1/1 7/2
 Ejemplo completo de una PILA en Python def main():
print ("¿Qué tarea desea realizar?")
pila = []
print ("Menú: ")
tope = int(input("Ingresa la dimensión de la pila: "))
print ("1) Eliminar elemento de la pila")
def desapilar():
print ("2) Agregar elemento a la pila")
if len(pila)>0:
print ("3) Ver si la pila está vacía")
print ("El número: ", pila.pop()," fue eliminado")
print ("4) Mostrar la pila")
main()
print ("5) Salir")
else:
opcion = input("Elige una opción: ")
print ("La pila está vacía")
if str(opcion)=="1":
main()
desapilar()
def apilar():
elif str(opcion)=="2":
if len(pila)<tope:
apilar()
x = input("Introduce el elemento que deseas agregar a la pila: ")
elif str(opcion)=="3":
pila.append(x)
vacia()
print ("El elemento ha sido agregado con éxito ")
elif str(opcion)=="4":
main()
mostrar()
else:
elif str(opcion)=="5":
print("Pila llena")
print ("Gracias por usar el programa.")
main()
pila = []
def vacia():
tope = int(input(«Ingresa la dimensión de la pila: «))
if len(pila)>0:
def desapilar():
print ("La pila no está vacía")
if len(pila)>0:
main()
print («El número: «,pila.pop(),» fue eliminado»)
else:
main()
print ("La pila está vacía")
else:
main()
print («La pila está vacía»)
def mostrar():
main()
if len(pila)>0:
def apilar():
print ("La pila es: ")
if len(pila)<tope:
for i in reversed(pila):
x = input(«Introduce el elemento que deseas agregar a la pila: «)
print(i)
pila.append(x)
main()
print («El elemento ha sido agregado con éxito»)
else:
main()
print("La pila está vacía")
else:
main()
print(«Pila llena»)
8 / 1/1 8/2
 main() exit()
def vacia(): else:
if len(pila)>0: print («La opción ingresada es incorrecta, por favor ingrese una opción
print («La pila no está vacía») válida»)
main() main()
else: main() exit()
print («La pila está vacía») else:
main() print ("La opción ingresada es incorrecta, por favor ingrese una opción
def mostrar(): válida")
if len(pila)>0: main()
print («La pila es: «) main()
for i in reversed(pila):
print(i)
main()
else:
print(«La pila está vacía»)
main()
def main():
print («¿Qué desea realizar?»)
print («Menú: «)
print («1) Eliminar elemento de la pila»)
print («2) Agregar elemento a la pila»)
print («3) Ver si la pila está vacía»)
print («4) Mostrar la pila»)
print («5) Salir»)
opcion = input(«Elige una opción: «)
if str(opcion)==»1″:
desapilar()
elif str(opcion)==»2″:
apilar()
elif str(opcion)==»3″:
vacia()
elif str(opcion)==»4″:
mostrar()
elif str(opcion)==»5″:
print («Gracias por usar el programa.»)
9 / 1/1 9/2
 EJERCICIOS PILAS que muestre por pantalla la suma de todos los números enteros. Al resolver el
problema habrá que tener en cuenta que, al ser enteros grandes, no pueden
1. Escriba un programa que reciba una Pila P de números enteros y mueva sus almacenarse en variables numéricas.
elementos a una nueva Pila, pero manteniendo el orden de salida de los mismos. Al
finalizar la Pila P no debe contener elementos. 13.Utilizar dos pilas para guardar los dos primeros números enteros, almacenándose
digito a dígito. Al extraer los elementos de la pila, salen en orden inverso y, por lo
2. Realizar un programa que cuente la cantidad de elementos de una pila. La estructura tanto, de menor peso a mayor peso; se suman digito con digito y el resultado se
debe quedar en el estado original. guarda en una cola, también digito a digito. A partir de este primer paso se obtienen
3. Realizar un procedimiento que invierta el orden de una pila. el siguiente número del archivo, se guarda en una pila y, a continuación, se suma
digito a dígito con el número que se encuentra en la cola; el resultado se guarda en
4. Realizar un procedimiento que saque el elemento N de una pila. Tener en cuenta que
otra cola. El proceso se repite, nuevo número del archivo se mete en la pila, que se
los demás elementos deben quedar en el mismo orden.
suma con el número actual de la cola.
5. Realizar un procedimiento que ingrese un elemento en la posición N de una pila.
Tener en cuenta que los demás elementos deben quedar en el mismo orden.
6. Escriba una rutina que reciba una Pila P de números enteros y mueva sus elementos
a una nueva Pila, pero invirtiendo el orden de salida de los mismos. Al finalizar la Pila
P no debe contener elementos.
7. Escriba una rutina que reciba dos Pilas P1 y P2 de números flotantes y apile las
mismas en una nueva Pila resultante. Es de destacar que las Pilas recibidas no deben
sufrir ningún tipo de cambio o alteración.
8. Escriba una rutina que reciba dos Pilas P1 y P2 de números enteros y proceda a
intercambiar sus elementos, pero manteniendo el orden de salida de los elementos.
Al finalizar la rutina, la Pila P1 tendrá los elementos de la Pila P2 y esta a su vez tendrá
los elementos de la Pila P1.
9. Escriba una rutina que reciba una Pila P de números enteros y devuelva una copia
exacta de la misma. Es de destacar que la Pila P no debe sufrir ningún tipo de cambio
o alteración.
10.Escriba una rutina que reciba una Pila P de números flotantes y devuelva una nueva
Pila pero con los elementos invertidos, es decir el último de la Pila P, pasará a ser el
primero de la nueva Pila Es de destacar que la Pila P no debe sufrir ningún tipo de
cambio o alteración.
11.Escriba una rutina que reciba una Pila P de números flotantes y devuelva otra pila,
manteniendo el orden de salida de los elementos. Es de destacar que la Pila P no
debe sufrir ningún tipo de cambio o alteración.
12.En un archivo f están almacenados números enteros arbitrariamente grandes. La
disposición es tal que hay un número entero por cada línea de F. Escribir un programa
10 //1 10 / 2
1