Pilas

Ahora se analiza un tipo de tabla llamada "Pila"
Concepto:
Una pila (stack en inglés) es una lista ordinal o estructura de datos en la que el modo de acceso a sus elementos es de tipo LIFO (del inglés Last In First Out, último en entrar, primero en salir) que permite almacenar y recuperar datos. Esta estructura se aplica en multitud de ocasiones en el área de informática debido a su simplicidad y ordenación implícita de la propia estructura.

Para el manejo de los datos se cuenta con dos operaciones básicas: apilar (push), que coloca un objeto en la pila, y su operación inversa, retirar (o desapilar, pop), que retira el último elemento apilado.
En cada momento sólo se tiene acceso a la parte superior de la pila, es decir, al último objeto apilado (denominado TOS, Top of Stack en inglés). La operación retirar permite la obtención de este elemento, que es retirado de la pila permitiendo el acceso al siguiente (apilado con anterioridad), que pasa a ser el nuevo TOS.
Por analogía con objetos cotidianos, una operación apilar equivaldría a colocar un plato sobre una pila de platos, y una operación retirar a retirarlo.

Tipo de Pila

En la figura F31-3 se presentan ejemplos de a) pila llena, b) pila con algunos elementos y c) pila vacía.

 -Aplicacion

Las pilas suelen emplearse en los siguientes contextos:

• Evaluación de expresiones en notación postfija (notación polaca inversa).
• Reconocedores sintácticos de lenguajes independientes del contexto
• Implementación de recursividad.

 -Codigo

• Pila Estatica 

public class PilaArray
{
 
 private int vector[];
 private int cima, tamano;


  public PilaArray( int tamano_p)//tamano de la pila parametro constructor
  {
    if( tamano_p < 0)
    {   
      tamano = 0; 
      System.err.println("Error, tamano no valido");
    }//fin if
    else
    {
       
       vector = new int[ tamano_p ];
       tamano = tamano_p;
       cima = -1;
    }//fin else   
   
   
     
  }
   
//para saber si la pila esta vacia
  public boolean vacia()
  {
   if(cima == -1)
       return true;
  
   return false;
  }
   
 
  //Devuelva true si logra insertar elemento
  public boolean inserta(int valor)
  {
    //si ya no hay espacio... 
    if( cima == tamano-1 )
    {
      System.err.println("OverFloat");
      return false;
    }   
    else
    {
      vector [ ++cima ] = valor;
      System.out.println("Agregado correctamente");
      return true;
    }   
  }
 
  //devuelve el valor de la cima de la pila
  public int cima()
  {
    //si la pila esta vacia... 
    if( vacia() ) 
    {
       System.err.println("La pila esta vacia");
       //si la pila esta vacia se retorna un 0 ... solo por ejemplo
      
       return 0;
    } 
    else
    {
      return vector[ cima-- ]; 
    }   
  }
 
  //limpia la pila
  public void vaciar()
  {
     cima = -1;
  }
 
 
}//fin clase pila

• Pila Dimanica

Codigo Main

import java.util.*;
public class Main
{
 public static void main(String[] args)
 {
  //Variables del Sistema
  Pila MiPila = new Pila(); //Variable tipo pila
  Scanner in=new Scanner(System.in);//Variable que lee desde teclado
  int intOpc1,intOpc2;//Variables que contienen la opcion elegida por el usuario
  try
  {
   //Cuerpo del Programa
   do
   {
    //Menu del Sistema
    System.out.print("---------------------------------------\n");
    System.out.print("           Sistema Multipila\n");
    System.out.print("---------------------------------------\n");
    System.out.print("1. Agregar Pila\n");
    System.out.print("2. Eliminar Pila\n");
    System.out.print("3. Ver Ultima Pila Ingresada\n");
    System.out.print("4. Salir\n\n");
    System.out.print("Opcion: ");
    //Lectura de la Opcion
    intOpc1=in.nextInt();
    //Filtramos Seleccion
    switch(intOpc1)
    {
        //Caso Agregar Pila
     case 1:System.out.print("Ingresa el Elemento de la Pila: ");
            MiPila.push(in.next());
            break;
     //Caso Eliminar Pila
     case 2:MiPila.pop();
            break;
     //Caso Ver Ultima Pila Registrada
     case 3:System.out.print("Ultimo Dato ingresado en la Pila: "+MiPila.getData()+"\n");
            break;
     //Caso Salir
     case 4:System.exit(0);
             break;
     //Caso Erroneo
     default: System.out.print("Opcion incorrecta!\n");
    }
   }while(intOpc1!=4);
  }
  catch (Exception e)
  {
      System.err.println("\nWARNING: " + e.getMessage());
  }
 }
}

Codigo Pila

public class Pila
{
 //Atributos de la Clase
 protected Object ArrDatos[];

 //Constructor de la Clase
 public Pila()
 {
  //Creamos el Arreglo de Elementos
  ArrDatos=new Object[0];
 }

 //Metodos de la Clase
 //->Determina si una pila esta vacia o no
 private boolean isEmpty()
 {
  if(ArrDatos.length==0)
      return true;
  else
      return false;
 }
 //->Redimensiona Pila
 private void redim(boolean bolParametro)
 {
  Object ArrAux[];
  //Filtramos el parametro de la funcion
  if (bolParametro)
  {
   //Si es + creamos un arreglo auxiliar con un elemento mas
   ArrAux=new Object[ArrDatos.length+1];
   //Recorremos el arreglo de datos
   for(int i=0;i<ArrDatos.length;i++)
    //pasamos la informacion al Auxiliar
    ArrAux[i]=ArrDatos[i];
  }
  else
  {
   //Si es - creamos un arreglo auxiliar con un elemento menos
   ArrAux=new Object[ArrDatos.length-1];
   //Recorremos el arreglo de datos
   for(int i=0;i<ArrAux.length;i++)
    //pasamos la informacion al Auxiliar
    ArrAux[i]=ArrDatos[i];
  }
  //Redimensionamos el Arreglo de Datos al tamaño final
  ArrDatos=new Object[ArrAux.length];
  //Pasamos toda la informacion del Auxiliar al Original
  ArrDatos=ArrAux;
 }
 //->Agrega elemento a Pila
 public void push(Object ObjDato)
 {
  //Redimensionamos el Arreglo
  redim(true);
  //Ingresamos elemento a pila
  ArrDatos[ArrDatos.length-1]=ObjDato;
 }
 //->Elimina elemento a Pila
 public void pop()
 {
  //Revisamos estado de la Pila
  if (!isEmpty())
      //Si contiene elementos Redimensionamos la Pila
      redim(false);
  else
      //Si esta vacia generamos una Excepción
      throw new RuntimeException("Pila Vacia...");
 }
 //->Obtiene dato de Pila
 public Object getData()
 {
  //Revisamos estado de la Pila
  if(!isEmpty())
      //Si contiene elementos mandamos el dato
      return(ArrDatos[ArrDatos.length-1]);
  else
      //Si esta vacia generamos una Excepción
      throw new RuntimeException("Pila Vacia...");
 }
}