Pila (informática) | pilas en java

Pilas en Java

Este tipo de estructura de datos se puede implementar de forma dinámica o estática, es decir, ya sea con un arreglo o con una lista enlazada. Al hablar de una pila estática, se considera que la pila tendrá un tamaño definido y no podrá superar dicha capacidad para el almacenamiento de más información, sólo la indicada. Y con respecto a una pila dinámica corresponde a una pila que no tendrá un límite de capacidad, es decir, podemos hacer n número de inserciones.

A continuación se presenta la Pila estática, la cual es implementada en base a un arreglo:

 1 public class PilaEstatica{
 2     private int pila[];
 3     private int top;//indica la posición del último elemento insertado
 4     private int capacidad;
 5    
 6     public PilaEstatica(int cap){
 7         capacidad=cap;
 8         pila=new int[capacidad];
 9         top=-1;
10     }
11    
12     public boolean estaVacia(){
13         return(top==-1);
14     }
15    
16     public boolean estaLlena(){
17         return((top+1)==capacidad);
18     }
19    
20     public void apilar(int elemento){
21         if(estaLlena()==false)
22             pila[++top]=elemento;
23         else
24             System.out.println("Desbordamiento superior, no se puede apilar");
25     }
26    
27     public int desapilar(){
28         if(estaVacia()==false){
29             return pila[top--];
30         }
31         else{
32             System.out.println("Desbordamiento inferior, no se puede desapilar");
33         }
34         return -1;
35     }
36       
37     public static void main (String args[]){
38         PilaEstatica pilita=new PilaEstatica(5); 
39         pilita.apilar(1);
40         pilita.apilar(12);
41         pilita.apilar(3);
42         int r=pilita.desapilar();
43         System.out.println("El dato eliminado es "+r);
44         boolean b=pilita.estaVacia();
45         boolean c=pilita.estaLlena();
46         System.out.println("¿Está vacia la pla? "+b);
47         System.out.println("¿Está llena la pla? "+c);
48       }
49    }


Enseguida se presenta la implementación de la Pila de forma dinámica, implementada en base a una lista simplemente enlazada:

Descargar Código.

Clase Nodo

 1 package pilas;
 2 /**
 3  *
 4  * @author Mauricio López Ramírez
 5  */
 6 public class Nodo {
 7 
 8     private char dato;
 9     private Nodo siguiente;
10     
11     public Nodo(char dato) {
12         this.dato = dato;
13     }
14     public char getDato() {
15         return dato;
16     }
17     public void setDato(char dato) {
18         this.dato = dato;
19     }
20     public Nodo getSiguiente() {
21         return siguiente;
22     }
23     public void setSiguiente(Nodo siguiente) {
24         this.siguiente = siguiente;
25     }
26 }

Clase Pila

 1 package pilas;
 2 /**
 3  *
 4  * @author Mauricio López Ramírez
 5  */
 6 public class Pila {
 7 
 8     Nodo tos;//Top Of Stack
 9 
10     public void apilar(char dato) {
11         Nodo nuevo = new Nodo(dato);
12         if (tos == null) {
13             tos = nuevo;
14         } else {
15             nuevo.setSiguiente(tos);
16             tos = nuevo;
17         }
18     }
19 
20     public char desapilar() {
21         Nodo temp = tos;
22         tos = tos.getSiguiente();
23         return temp.getDato();
24     }
25 
26     public void imprimir() {
27         Nodo temp = tos;
28         while (temp != null) {
29             System.out.print(temp.getDato() + "\n");
30             temp = temp.getSiguiente();
31         }
32     }
33 
34 }

Clase Manejador

 1 package pilas;
 2 
 3 /**
 4  *
 5  * @author Mauricio López Ramírez
 6  */
 7 public class Manejador {
 8     
 9     public static void main(String[] args) {
10         Pila nuevaPila = new Pila();
11         nuevaPila.apilar('A');
12         nuevaPila.apilar('B');
13         nuevaPila.apilar('C');
14         nuevaPila.imprimir();
15         System.out.println();
16         nuevaPila.desapilar();
17         nuevaPila.imprimir();
18     }
19 
20 }