Pilas en Java

Una pila (stack) es una colección ordenada de elementos a los que sólo se puede acceder por un único lugar o extremo de la pila.  Al primer elemento agregado se lo denomina como "fondo", mientras que al último se lo conoce como "cima". Los elementos de la pila se añaden o se borran de la misma sólo por su parte superior (cima).

Debido a su propiedad específica “último en entrar, primero en salir ” se conoce a las pilas como

estructura de datos LIFO (last-in / first-out). 

Una pila es una estructura para el almacenamiento de datos, en la cual la información posee solamente una entrada y salida para su acceso, es decir mantiene una estructura LIFO(Last in First out) lo que quiere decir que el ultimo elemento ingresado debe ser el primero al cual accedemos, por ende el primer elemento ingresado puede solamente ser visto si pasamos por todos los elementos de la Pila.Dentro de java podemos acceder a este tipo de clase mediante el uso de la clase Stack.

Una pila se puede implementar de las siguientes formas:

1. Guardando los elementos en un arreglo en cuyo caso su dimensión o longitud es fija. 
2. Utilizando un vector para almacenar los elementos. 
3. Construir una lista enlazada, cada elemento de la pila forma un nodo de la lista; la lista crece o decrece según se añaden o se extraen, respectivamente, elementos de la pila; ésta es una representación dinámica y no existe limitación en su tamaño excepto la memoria de la computadora.

Operaciones de las Pilas:

Una pila cuenta con 2 operaciones imprescindibles:

Apilar (push): 

Consiste en añadir un elemento a la pila. En la siguiente imagen se explica de una forma más abstracta en la que se puede ver que se está añadiendo el dato "7" sobre el dato "8", convirtiéndose éste en la "cima" de la pila.

Desapilar (pop): 

Es la operación contraria de "apilar", es decir, en lugar de añadir elementos a la pila, se los va a quitar de la misma. En la siguiente imagen se explica de una forma más abstracta en la que se puede ver que se está quitando de la pila el dato "7" establecido anteriormente como la "cima".

Ejemplo práctico:

Clase pilas

package estructurasDeDatos;

public class Pila {
 private int[] pila;
 private int top;
 private int tamanioPila;
 
 public Pila(){
  tamanioPila = 1;
  top = -1;
  pila = new int[tamanioPila];
 }
 
 //las operaciones basicas de la pila
 public void push(int dato){
  if (top == (tamanioPila -1))
   redimensionar();
  pila[++top] = dato;
 }
 
 public Integer pop(){
  if(top < 0)
   return null;
  return pila[top--];
 }
 
 private void redimensionar(){
  int[] temp = pila;
  tamanioPila *= 2;
  pila = new int[tamanioPila];
  
  for(int i = 0; i <= top; i++)
   pila[i] = temp[i];
 }
}

Clase principal

package estructurasDeDatos;

public class PilaPrueba {

 public static void main(String[] args) {
  Pila pila = new Pila();
  
  pila.push(10);
  pila.push(20);
  pila.push(30);
  
  System.out.println(pila.pop());
  System.out.println(pila.pop());
  System.out.println(pila.pop());
  System.out.println(pila.pop());
 }

}

Después de las dos operaciones fundamentales en una pila, se pueden establecer otras, las cuales servirán para obtener información y manipular su contenido:

CrearPila: Inicia la pila

Pila vacía (Empty): Comprueba si la pila no tiene elementos

Pila llena: Comprueba si la pila está llena de elementos

Limpiar pila: Quita todos sus elementos y deja la pila vacía

CimaPila (Peek): Obtiene el elemento cima de la pila

Tamaño de la pila: Número de elementos máximo que puede contener la pila

Buscar (Search): Busca un elemento determinado que esté dentro de la pila y devuelve su posición.

Una pila es una estructura de datos del tipo LIFO, con dos operaciones imprescindibles: apilar (push) y desapilar (pop), al primer elemento se lo conoce como "fondo" y al último como "cima".

Aplicaciones de las Pilas

Cuando un programa llama a un subprograma, internamente, se utilizan pilas para guardar el lugar desde donde se hizo la llamada, y el estado de las variables en ese momento.
Otro ejemplo es que todo algoritmo recursivo, puede ser implementado en forma iterativa utilizando una pila para almacenar los valores de las variables y parámetros.

En java podemos importar la librería java.util.Stack

Con las Pilas podemos hacer operaciones como Push (apilar)

Push o apilar .-los elementos se introducen en la pila por un extremo

POP .- sacar datos de la pila (desapilar)

EMPTY.- comprueba si la pila está vacía.

PEEK (consulta el primer elemento de la cima de la pila)

SEARCH (que busca un determinado elemento dentro de la pila y devuelve su posición dentro de ella).

Código Pila

            import java.util.Stack;

public class Principal {

    public static void main(String[] args) {
   
        Stack pila=new Stack();
        for(int x=5;x<=10;x++){
            pila.push(Integer.toString(x));
            while(!pila.empty()){
                System.out.println(pila.pop());
            }
        }
    }
    
}

EXPRESIONES InFija, PreFija Y PosFija

PreFija:Notación prefija: El orden es operador, primer operando, segundo operando

InFija: Notación infija: La notación habitual. El orden es primer operando, operador, segundo operando

PosFija:Notación postfija: El orden es primer operando, segundo operando, operador

Código de ejemplo de tratamiento de expresiones posfija

            import java.util.Stack;
/**
 *
 * @author Administrador
 */
public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //Entrada (Expresión en Postfija)
        String expr = "2 23 6 + * 1 -"; // equivale a 2*(23+6)-1
        String[] post = expr.split(" ");    

        //Declaración de las pilas
        Stack < String > E = new Stack < String > (); //Pila entrada
        Stack < String > P = new Stack < String > (); //Pila de operandos

        //Añadir post (array) a la Pila de entrada (E)
        for (int i = post.length - 1; i >= 0; i--) {
          E.push(post[i]);
        }

        //Algoritmo de Evaluación Postfija
        String operadores = "+-*/%"; 
        while (!E.isEmpty()) {
          if (operadores.contains("" + E.peek())) {
            P.push(evaluar(E.pop(), P.pop(), P.pop()) + "");
          }else {
            P.push(E.pop());
          } 
        }

        //Mostrar resultados:
        System.out.println("Expresion: " + expr);
        System.out.println("Resultado: " + P.peek());

      }

      private static int evaluar(String op, String n2, String n1) {
        int num1 = Integer.parseInt(n1);
        int num2 = Integer.parseInt(n2);
        if (op.equals("+")) return (num1 + num2);
        if (op.equals("-")) return (num1 - num2);
        if (op.equals("*")) return (num1 * num2);
        if (op.equals("/")) return (num1 / num2);
        if (op.equals("%")) return (num1 % num2);
        return 0;
      }
}

Referencias:

• Alvarez,D.(2011).Pilas en Java.Recuperado el 28 de noviembre de 2016 de http://soloinformaticayalgomas.blogspot.com/2011/02/pilas-en-java.html
• Sierra,M(s,n).La estructura de datos pila en java.Clase Stac del API Java.Ejemplo Simple y ejercicios resueltos.Recuperado el 28 de noviembre de 2016 de http://aprenderaprogramar.com/index.php?option=com_content&view=article&id=608:la-estructura-de-datos-pila-en-java-clase-stack-del-api-java-ejemplo-simple-y-ejercicios-resueltos-cu00920c&catid=58:curso-lenguaje-programacion-java-nivel-avanzado-i&Itemid=180
• Alvarez,D.(2011).Colas en Java.Recuperado el 28 de noviembre de 2016 de http://soloinformaticayalgomas.blogspot.com/2011/03/colas-en-java.html