Pilas (Stacks)

 Desde el punto de vista teórico una pila es un tipo de dato abstracto (TDA) que sigue el principio LIFO (last in, first out) que implica que el último elemento en ser agregado en la pila es también el primero en ser removido de la misma.

En la imagen se observa una pila con tres elementos, cuando se inserta uno nuevo, este se coloca al final de la pila (elemento D).

Cuando se elimina un elemento, se remueve el último en haber ingresado, en caso de la pila es el elemento D.

En el mundo real podemos encontrar este ejemplo al apilar platos en un punto, cuando queremos mover los platos uno por uno se comienza retirando el último plato colocado.

Stacks en Java

Se puede crear una pila de forma sencilla con la clase Stack que hereda de la clase Vector.

El siguiente ejemplo ilustra como construir una pila, agregar elementos y luego irlos retirando. Para ello, se crea una colección llamada pila de tipo Stack que almacena valores enteros.

package test;

import java.util.Stack;

public class Pilas {

    public static void main(String[] args) {
        Stack<Integer> pila = new Stack<>();

        System.out.println("Agregando valores");
        for (int i = 0; i < 5; i++) {
            pila.push(i);
            System.out.println("Valor: " + i);
        }
        
        System.out.println("\nRetirando valores");
        while (!pila.isEmpty()) {
            System.out.println("Valor: " + pila.pop());            
        }
    }
}

La salida del resultado sería:

Agregando valores
Valor: 0
Valor: 1
Valor: 2
Valor: 3
Valor: 4

Retirando valores
Valor: 4
Valor: 3
Valor: 2
Valor: 1
Valor: 0

El último elemento en ser agregado es "4" y al retirar a los elementos, el primero en ser removido también es el "4" comprobando el principio LIFO.

Creando una clase Colas

La siguiente clase emula de forma simple el funcionamiento de una cola, para ello utiliza un array de tipo Object

package tda;

public class Pilas {

    private Object[] data;
    private final int length;
    private int pointer;

    public Pilas(int length) {
        this.length = length;
        this.data = new Object[length];
        this.pointer = -1;
    }

    public void add(Object element) {
        this.data[pointer+1] = element;
        pointer = (pointer < length - 1) ? pointer + 1 : pointer;
    }

    public Object[] getData() {
        return this.data;
    }

    public int getLength() {
        return length;
    }

    public Object pop() {
        Object value = this.data[pointer];
        this.data[pointer] = null;
        pointer--;
        return value;
    }
}

Para comprobar el funcionamiento se utiliza lo siguiente:

package test;

import java.util.Arrays;
import tda.Pilas;

public class TestPilas {

    public static void main(String[] args) {
        Pilas pilaInt = new Pilas(4);
        pilaInt.add(0);
        pilaInt.add(1);
        pilaInt.add(2);
        pilaInt.add(3);
        for (int i = 0; i < 4; i++) {
            System.out.println("Dato ingresado: "+pilaInt.getData()[i]);
        }
        System.out.println("=================================");
        System.out.println("Sale: "+pilaInt.pop());
        System.out.println("Sale: "+pilaInt.pop());
        System.out.println("Sale: "+pilaInt.pop());
        pilaInt.add(5);
        System.out.println("=================================");
        System.out.println(Arrays.toString(pilaInt.getData()));
    }
}

La salida del resultado sería:

Dato ingresado: 0
Dato ingresado: 1
Dato ingresado: 2
Dato ingresado: 3
=================================
Sale: 3
Sale: 2
Sale: 1
=================================
[0, 5, null, null]

Se comprueba el principio LIFO al insertar al final el 3, el primero en ser retirado es el mismo 3