RAMÓN TOALA DUEÑAS

DOCENTE:

CONTENIDO:
Listas dinámicas - PILAS

Periodo: Mayo a Septiembre 2022

Retroalimentación:
Interrogantes de la clase anterior, el estudiante debe contestar estas
preguntas con sus propias palabras y ejemplos

1. ¿Cómo se puede incluir otras clases a nuestras aplicaciones?

2. ¿Qué es un ArrayList?
3. ¿Qué procesos internos hace el ArrayList para almacenar nuevos datos cuando
se llena?
4. ¿Qué es un nodo y para qué sirve?
5. ¿Qué es una Listas simplemente enlazadas y una Listas doblemente enlazadas?
6. ¿Qué es una Listas circular simplemente enlazada y una lista circular
doblemente enlazada?
7. ¿Qué es una Pila y una Cola?
8. ¿Qué es un Mapa y un Conjunto?
Objetivos de la Clase:

Entender como funciona una Pila y como aplicar sus reglas al

desarrollar los diferentes métodos en clases modelos.

Desarrollar aplicaciones que permitan la gestión de datos utilizando

Pilas
Desarrollo de Pilas
Para la comprensión de este material académico y como estrategia de enseñanza para cada tipo de estructura de datos que se verán en el
transcurso del semestre, se desarrollará una clase para encapsular la estructura del nodo, otra clase para trabajar con la estructura que incluirá
sus respectivos métodos y una última clase para ejecutar la funcionalidad de la estructura.
Recordemos que este tipo de estructura de datos, los elementos pueden son insertados (Aplilados) o extraídos
(Desapilados), son realizados desde uno de los extremos
Recuerde que para trabajar con este tipo de lista se debe aplicar la regla LIFO (Last Input, First Output / último en
entrar, primero en salir)
Considere que la Pila es un tipo de lista, como tal, cada elemento de la lista es una variable dinámica (Se crea al momento de ejecutar el
programa), por lo que cada variable dinámica debe tener la referencia a la siguiente.
Para crear la estructura de la variable dinámica se utiliza la siguiente clase: // Métodos get y set para los atributos.
public int getValor() {
public class Nodo { Recuerde que
return valor;
private int valor; // Variable o lista de variables para guardar datos. los métodos
}
private Nodo sig; // Atributo para hacer referencia al nodo siguiente. Get y Set
public void setValor(int valor) {
sirven para
El atributo valor es un modelo que puede ser reemplazado por otros atributos, el this.valor = valor;
extraer e
atributo Sig será quien almacene la referencia a la siguiente variable sin nombre, }
insertar
observe que este atributo es del mismo tipo de la clase Nodo public Nodo getSiguiente() {
valores a cada
return sig;
// Métoso constructor que inicializamos el valor de las variables. atributo de la
}
public void Nodo(){ Recuerde que los métodos constructores sirven para clase porque
public void setSiguiente(Nodo sig) {
this.valor = 0; son privados
inicializar los atributos, así valor tomará cero y Sig this.sig = sig;
this.sig = null; tomará null que significa último de la estructura }
} }
Desarrollo de Pilas
Una vez que se tiene la clase Nodo (encapsula las variables dinámicas), se crea la clase pila que contendrá las operaciones
básicas que se realizan con una pila:
public class Pila { El atributo inicio es una variable estática de tipo Nodo que sirve
private Nodo inicio; para referenciar siempre a la primera variable dinámica de la pila
//Método constructor
public void Pila(){ Esto significa que se inicializa como Pila IsEMPTY – EstaVACIA.- Estos términos son utilizados como nombres
inicio = null; vacía de los métodos que devuelven VERDADERO si una pila está vacía o
} FALSO en caso que contenga algún elemento. La pila es una
//Método IsEmpty Esto es una operación lógica que estructura que necesita un nodo que almacene la referencia al primer
public boolean esVacia(){ devuelve Verdadero o Falso nodo de la pila, cuando la referencia tiene un valor NULL significa que
return inicio == null; dependiendo del valor que tenga inicio la pila está vacía.
}
 PUSH – INSERTAR- APILAR .- Estos términos son utilizados como nombres de los métodos que
//Método Push identifican la acción de agregar elementos a la pila, el proceso se basa en ubicar la variable dinámica
public void apilar(int valor){ (Nodo) siempre al principio de la pila, para esto recibe el valor que desea insertar.
Nodo nuevo = new Nodo();
nuevo.setValor(valor); Este proceso crear una variable dinámica, la variable nuevo toma la referencia de esa variable sin nombre
if (esVacia()) {
Este proceso se realiza cuando la Pila esta vacía, es decir la variable estática inicio toma la referencia de la
inicio = nuevo;
primera variable dinámica.
}
else{
Este proceso se lo conoce como el amarre, se produce cuando la pila tienen nodos o NO esta
nuevo.setSiguiente(inicio);
vacía, consiste en que la nueva variable sin nombre tome la referencia del nodo superior y la
inicio = nuevo;
variable estática inicio toma la referencia de la nueva variable dinámica.
}
}
PUSH – INSERTAR- APILAR
Por la importancia del método se lo explicará al detalle, para probar el funcionamiento del algoritmo considere que para agregar
un nodo a la Pila existen 2 instantes: Cuando la pila esta vacía y cuando la pila tiene elementos:

CUANDO LA PILA ESTA VACÍA:

Inicio
ALGORITMO DE INSERCIÓN: 10
null
public void apilar(int valor){
Nodo nuevo = new Nodo();
nuevo.setValor(valor); 10
if (esVacia()) { 1
A inicio = nuevo;
}
else{
B nuevo.setSiguiente(inicio); CUANDO LA PILA NO ESTA VACÍA:
C inicio = nuevo;
} 10 35
}

35 1 10
2
PUSH – INSERTAR- APILAR
Suponga que se desea insertar los siguientes elementos: 3, 1, 4, 8, 7
ALGORITMO DE INSERCIÓN:

public void apilar(int valor){ Inicio

Nodo nuevo = new Nodo(); null
1
nuevo.setValor(valor);
2
if (esVacia()) { 3
inicio = nuevo; 4
} 5
else{
nuevo.setSiguiente(inicio);
inicio = nuevo; Considerando que las variables dinámicas no tienen nombres
} se las dibujará en forma de Nodos para su comprensión:
}

//Método que devuelve True o False 7 4 8 3 4 2 1 1 3 null

public boolean esVacia(){
return inicio == null;
}
POP – RETIRAR -- DESAPILAR
Los términos pop, retirar o desapilar son utilizados para identificar el o los métodos que realizan la acción de extraer o quitar elementos a la pila,
el proceso se basa en modificar la referencia de la variable estática tomando la referencia de la siguiente variable dinámica o Nodo, siempre al
principio de la pila para cumplir con el método LIFO (último en entrar primero en salir).

Observe que este método debe devolver un valor de tipo integer, en caso de que la pila este
vacía, la instrucción MAX_VALUE, devuelve el valor máximo que puede almacenar un dato de
//Método Pop tipo integer, esta posibilidad puede ser modificada ya que el valor a retornar puede ser
public int desapilar () { cualquiera que identifique que la Pila esta vacía,
if (!esVacia())
Suponga que se tiene la siguiente pila y se ejecuta el método:
{ int dato = inicio.getValor();
A inicio = inicio.getSiguiente(); dato
return dato; 11 2
}
else
{ return Integer.MAX_VALUE; A
}
} Al momento que ocurre el proceso A la eliminación del nodo 3 es
automática porque Java utiliza referencias
La clase Pila con los métodos analizados:
La clase Pila utiliza una variable estática de tipo Nodo para controlar las variables dinámicas de la estructura de la pila
La Primera clase será la que La Segunda clase será la que corresponde //Método Pop
corresponde al Nodo: a la Pila y utiliza la clase Nodo: public int desapilar () {
public class Nodo { public class Pila { if (!esVacia())
private int valor; private Nodo inicio; { int dato = inicio.getValor();
private Nodo sig; //Método constructor inicio = inicio.getSiguiente();
// Métoso constructor public void Pila(){ return dato;
public void Nodo(){ inicio = null; }
this.valor = 0; } else
this.sig = null; //Método IsEmpty { return Integer.MAX_VALUE;
} public boolean esVacia(){ }
// Métodos get y set return inicio == null; } La Tercera clase será la que corresponde a las instrucciones que
public int getValor() { } } aplican la Pila y prueba su funcionamiento:
return valor; //Método Push //Instrucciones para probar la Pila
} public void apilar(int valor){ public static void main(String[] args) {
public void setValor(int valor) { Nodo nuevo = new Nodo(); Pila pila = new Pila();
this.valor = valor; nuevo.setValor(valor); pila.apilar(4);
} if (esVacia()) { pila.apilar(16);
public Nodo getSiguiente() { inicio = nuevo; pila.apilar(12);
return sig; } pila.apilar(8);
} else{ pila.apilar(65);
public void setSiguiente(Nodo sig) { nuevo.setSiguiente(inicio); System.out.println(“Elemento: " + pila.desapilar() + " Sale");
this.sig = sig; inicio = nuevo; System.out.println(“Elemento: " + pila.desapilar() + " Sale");
} } System.out.println(“Elemento: " + pila.desapilar() + " Sale");
} } }
Otros métodos de la clase pila: (Verifica la existencia de un nodo)
Este Algoritmo busca un elemento en la pila. El parámetro referencia es el valor del nodo a buscar. Además devuelve true si el
valor de referencia existe en la pila.
El siguiente algoritmo no cumple con las reglas de la Pila donde define que nodo utilizado nodo eliminado, pero define el procedimiento para
recorrer una estructura y localizar un determinado elemento:

public boolean buscar(int aBuscar){

Nodo aux = inicio; // aux toma la referencia del Nodo tope de la pila.
boolean existe = false; //existe es utilizada para verificar si se encuentra el elemento a buscar.
// El siguiente proceso permite recorrer la pila hasta encontrar el Nodo o llegar al final
while(existe != true && aux != null){
//Este proceso compara si el valor del nodo es igual al valor a buscar.
if (aBuscar == aux.getValor()) {
existe = true; //existe indicará que el valor fue encontrado.
} else{
aux = aux.getSiguiente(); //aux avanza al siguiente nodo. aBuscar Existe
} 11 false
} true
return existe; //Termina y retorna true o false.
}

Aux Aux Aux Aux

6 5 4 3
Otros métodos de la clase pila:
En Java una vez que una variable dinámica no se encuentra referenciada se elimina automáticamente
// Método elimina pila
public void eliminar(){
inicio = null; null
}

Otra alternativa de extraer un elemento sin la necesidad de devolver el valor del nodo:
public void retirar(){
if (!esVacia()) {
inicio = inicio.getSiguiente(); 2
}
}
Asumiendo que se desea mostrar toda la información de la Pila:

public void mostrarPila(){

Nodo aux = inicio; // Crea una copia de la pila.
// Recorre la pila hasta el último nodo.
while(aux != null){ Aux Aux Aux Aux Aux
4 3 1 null
System.out.println("|\t" + aux.getValor() + "\t|"); 2
aux = aux.getSiguiente();
} Mostrará: | 17 |
} | 11 |
| 8 |
| 23 |
Otros métodos de la clase pila:
El siguiente método desea mostrar toda la información de la Pila:
public int cantidad() { cant
int cant=0; 0
Nodo aux=inicio; 1
while (aux!=null) { 2
Aux Aux Aux Aux Aux
cant++; 3 4 3 null
2 1
aux= aux.getSiguiente(); 4
}
return cant;
}
Cuando se trabaja con variables dinámicas (Variables que no existen en la zona de la RAM para nombres de variables) se pueden presentar varios
problemas que se los tratará poco a poco a medida que se tratan las diferentes estructuras, por ejemplo:
No se puede consultar el valor de un nodo que NO existe, para evitar un error de ejecución Java permite utilizar excepciones.
El siguiente algoritmo consulta el valor del nodo que se encuentra en la cima de la pila sin eliminarlo tipo Peek, el método retorna el valor del
nodo, en caso de estar vacía la Pila utilizará throws Exception para evitar un error de ejecución:
public int cima() throws Exception{ El manejo de excepciones es una técnica de programación que
if(!esVacia()){ permite al programador controlar los errores ocasionados durante la
return inicio.getValor(); ejecución de un programa informático.
} else {
throw new Exception("La pila se encuentra vacía."); Las excepciones se usan para indicar que se ha producido un error
} mientras se ejecutaba el programa. Se crean los objetos de
} excepción que describen un error y, luego, se producen con la
palabra clave throw.
Otra forma de crear toda la estructura de la pila: (En este ejemplo se crea todo en una sola clase)
public class Pila { public int extraer() {
if (tope!=null) { public static void main(String[] ar) {
//Clase que crea la estructura del Nodo
int valorrmacion = tope.valor; Pila pila1=new Pila();
class Nodo {
tope = tope.sig; pila1.insertar(10);
int valor;
return valorrmacion; pila1.insertar(40);
Nodo sig;
} pila1.insertar(3);
}
else { pila1.imprimir();
//Variable estática que controla la Pila
return Integer.MAX_VALUE; System.out.println("Extraemos Nodo:"+pila1.extraer());
private Nodo tope;
} pila1.imprimir();
//Inicialización en el constructor
} System.out.println("Retornamos Nodo:"+pila1.retornar());
Pila () {
pila1.imprimir();
tope=null; public int retornar () { }
} if (tope!=null) { }
public void insertar(int x) { int dato = tope.valor;
Nodo nuevo; return dato;
nuevo = new Nodo(); }
nuevo.valor = x; else {
if (tope==null) return Integer.MAX_VALUE;
{ }
nuevo.sig = null; }
tope = nuevo;
} public void imprimir() {
else Nodo reco=tope;
{ System.out.println("Listado de todos los elementos de la pila.");
nuevo.sig = tope; while (reco!=null) {
System.out.print(reco.valor+"-"); En esta lección se ha analizado 2 metodologías para
tope = nuevo;
} reco=reco.sig; crear una estructura tipo Pila, en ambas se utiliza los
} } mismos métodos. Queda a su criterio escoger la
System.out.println(); metodología con la que desea aplicar sus propuestas
} de solución a los problemas que se les plantee.
CONCLUSIONES
 Las reglas de una estructura Pila pueden ser aplicadas tanto para arreglos estáticos, dinámicos como para
estructuras dinámicas como una lista.
 Aunque no es una regla, la estructura del Nodo de una pila debe poseer en su definición al menos un dato
para contener como información y obligatoriamente una variable que contenga la referencia a otra variable
dinámica del mismo tipo de la estructura de la pila.
 Una pila utiliza de forma obligatoria los métodos: PUSH - INSERTAR- APILAR para agregar elementos al tope
de la pila y POP-RETIRAR-DESAPILAR para extraer el último elemento insertado en la pila.
 PUSH - INSERTAR- APILAR es un método que agrega siempre los Nodos al principio de la lista utilizando dos
instrucciones, La primera instrucción hace que la nueva variable dinámica tome la referencia de la última
insertada (al principio) y la segunda instrucción hacer que la variable estática (la que tiene la referencia a la
pila) almacene la referencia de la nueva variable dinámica (La de la primera instrucción).
 POP-RETIRAR-DESAPILAR este método se encarga de extraer el valor del primer Nodo de la lista (último
insertado) y después toma la referencia del segundo Nodo y lo establece como el primero, así el antiguo
primer nodo queda sin referencia y es eliminado automáticamente de la memoria.
 No es común que se realicen otros procesos con la lista tipo Pila porque se estarían violando las reglas básicas
de la estructura, pero se puede recurrir a las copias de los datos para realizar recorridos y otros procesos que
normalmente se realizan con las listas estructuradas.
ACTIVIDADES A DESAROLLAR :

MATERIAL EXTRA DE APOYO

Creación de los métodos básicos de la Pila
https://www.youtube.com/watch?v=JZqxk079LzE
https://www.youtube.com/watch?v=6tlsWI4mrgQ
https://www.youtube.com/watch?v=6HQ2uQrD68Q