PILAS EN JAVA

Lo primero que se debe saber del tema Pilas en java es ¿Que es una Pila?

Una pila es una estructura que nos permite apilar elementos y recopilarlos en el orden inverso al cual los apilamos mediante operaciones de desapilar. Esto es lo que se conoce como estructuras LIFO (Last In First Out).

 La spilas tinen tres operaciones con las cuale se pueden trabajar que son las siguientes:

1. apilar, añade un elemento a la lista.
2. desapilar, retira un elemento de la lista
3. está vacía, comprueba si la lista está vací. 

Los metodos que se utilizan para realizar estas operaciones con pilas son las siguientes:

•  PUSH (pila, elemento): Introduce un elemento en la pila. También se le conoce como poner o meter.
•  POP (pila): Elimina un elemento de la pila. También se le conoce como sacar o quitar. 
•  VACIA(pila): Función booleana que indica si la pila esta vacía o no. 

Ejemplo de como se almcena una pila en java.

Mapa Conceptual Pilas 

 Programa PILAS

Clase Nodo

 
    public class Nodo {
    
    private int valor;
    private Nodo siguiente;
   
    public void Nodo(){
        this.valor = 0;
        this.siguiente = null;
    }
    
    // Métodos get y set para los atributos.
    
    public int getValor() {
        return valor;
    }

    public void setValor(int valor) {
        this.valor = valor;
    }

    public Nodo getSiguiente() {
        return siguiente;
    }

    public void setSiguiente(Nodo siguiente) {
        this.siguiente = siguiente;
    }   
    

       
 
 

Clase Pila 

    

  public class Pila {
    
    private Nodo inicio;
    private int tamanio;
    
    public void Pila(){
        inicio = null;
        tamanio = 0;
    }
    
    public boolean esVacia(){
        return inicio == null;
    }
    
    public int getTamanio(){
        return tamanio;
    }
    
    public void apilar(int valor){
    
        Nodo nuevo = new Nodo();
        nuevo.setValor(valor);
        if (esVacia()) {
            inicio = nuevo;
        }
        
        else{
            nuevo.setSiguiente(inicio);
            inicio = nuevo;
        }
        
        tamanio++;
    } 
    
    public void retirar(){
        if (!esVacia()) {
            // Asigna como primer nodo al siguiente de la pila.
            inicio = inicio.getSiguiente();
            // Decrementa el contador del tamaño de la pila
            tamanio--;
        }
    }
    
    public int cima() throws Exception{
        if(!esVacia()){
            return inicio.getValor();
        } else {
            throw new Exception("La pila se encuentra vacia.");
        }
    }
    
    public boolean buscar(int referencia){
    
        Nodo aux = inicio;
        boolean existe = false;
        
        while(existe != true && aux != null){
        
            if (referencia == aux.getValor()) {
                // Cambia el valor de la bandera.
                existe = true;
            }
            else{
                // Avanza al siguiente nodo.
                aux = aux.getSiguiente();
            }
        }
        // Retorna el valor de la bandera.
        return existe;
    }
      
    public void remover(int referencia){
        // Consulta si el valor existe en la pila.
        if (buscar(referencia)) {
            // Crea una pila auxiliar para guardar los valores que se 
            // vayan desapilando de la pila original.
            Nodo pilaAux = null;
            while(referencia != inicio.getValor()){
                Nodo temp = new Nodo();
                temp.setValor(inicio.getValor());
                if(pilaAux == null){
                    pilaAux = temp;
                }
                else{
                    temp.setSiguiente(pilaAux);
                    pilaAux = temp;
                }
                retirar();
            }
           retirar();
           while(pilaAux != null){
                apilar(pilaAux.getValor());
                pilaAux = pilaAux.getSiguiente();
            }
    
            pilaAux = null;
        }
    }    
    public void editar(int referencia, int valor){
        // Consulta si el nodo existe en la pila
        if (buscar(referencia)) {
            // Crea una pila auxiliar.
            Nodo pilaAux = null;
            while(referencia != inicio.getValor()){
                Nodo temp = new Nodo();
                // Ingresa el valor al nodo temporal.
                temp.setValor(inicio.getValor());
                // Consulta si la pila auxiliar no a sido inicializada.
                if(pilaAux == null){
                    // Inicializa la pila auxiliar.
                    pilaAux = temp;
                }
                else{
                    temp.setSiguiente(pilaAux);
                    pilaAux = temp;
                }
                retirar();
            }
            // Actualiza el valor del nodo.
            inicio.setValor(valor);
            while(pilaAux != null){
                apilar(pilaAux.getValor());
                // Avansa al siguiente nodo de la pila auxiliar.
                pilaAux = pilaAux.getSiguiente();
            }
            // Libera la memoria utilizada por la pila auxiliar.
            pilaAux = null;
        }
    }
    public void eliminar(){
        // Elimina el valor y la referencia a los demas nodos.
        inicio = null;
        // Reinicia el contador a 0.
        tamanio = 0;
    }
    public void listar(){
        Nodo aux = inicio;
        while(aux != null){
            System.out.println("|\t" + aux.getValor() + "\t|");
            System.out.println("-----------------");
            aux = aux.getSiguiente();
        }
    }
}       

       
 

Main Principal

    
public static void main(String[] args) {
        Pila pila = new Pila();
        
        System.out.println("<<-- --="" de="" ejemplo="" pila="">>\n\n");
        
        pila.apilar(4);
        pila.apilar(16);
        pila.apilar(12);
        pila.apilar(8);
        pila.apilar(65);
        
        System.out.println("<<-- --="" pila="">>");
        pila.listar();
        System.out.println("\n<<-- --="" o="" tama="">");
        System.out.println(pila.getTamanio());
        
        System.out.println("\n<<-- --="" de="" del="" el="" elemento="" la="" pila="" retirar="" tope="">>");
        pila.retirar();
        pila.listar();
        System.out.println("Tamaño: " + pila.getTamanio());
        
        System.out.println("\n<<-- --="" 12="" 24="" actualizar="" con="" del="" el="" nodo="" por="" valor="">>");
        pila.editar(12, 44);
        pila.listar();
        System.out.println("Tamaño: " + pila.getTamanio());
        
        System.out.println("\n<<-- --="" 16="" con="" el="" eliminar="" nodo="" valor="">>");
        pila.remover(16);
        pila.listar();
        System.out.println("Tamaño: " + pila.getTamanio());
        
        System.out.println("\n<<-- --="" 65="" consulta="" el="" existe="" si="" valor="">>");
        System.out.println(pila.buscar(65));
        
        System.out.println("\n<<-- --="" elimina="" la="" pila="">>");
        pila.eliminar();
        
        System.out.println("\n<<-- --="" consulta="" esta="" la="" pila="" si="" vacia="">>");
        System.out.println(pila.esVacia());
        
        System.out.println("\n\n<<-- --="" de="" ejemplo="" fin="" pila="">>");
    }
    }