Estructuras de datos: Pilas

En el campo de la computación hay ciertas formas de organizar, manipular y almacenar la información, una de ellas es la forma de pila, en esta se trabaja con un arreglo el cual tiene un comportamiento LIFO (Last In First Out), esto significa que el último dato ingresado en el arreglo será el primero en salir, se puede hacer una comparación con bultos de cemento uno encima de otro, cada que se agregue otro bulto este va a quedar en el tope del grupo y si se quiere sacar manualmente por ejemplo el bulto de la mitad, primero se tienen que sacar todos los bultos que están encima de este.

La programación fue realizada en Java y se hizo uso de una interfaz la cual contiene todos los métodos a implementar, una clase que implementa tales métodos y una última clase que se utiliza para hacer pruebas e imprimir en pantalla.

• Interfaz

  package Pila;
   
  /**
   * @author Daniel Cataño Restrepo
   * @param < E > Dato genérico, este se define en el momento de crear un objeto de tipo Pila
   */
  public interface IPila< e >{
      
      /**
       * Método para conocer si el arreglo está vacío
       * @return true si está vacío, false si no.
       */
      public boolean isEmpty();
      
      /**
       * 
       * @return el elemento en el tope del arreglo
       */
      public E peek();
      
      /**
       * Remueve el primer elemento del arreglo
       * @return el elemento removido
       */
      public E pop();
      
      /**
       * Imprime el arreglo
       */
      public void print();
      
      /**
       * Agrega un elemento al inicio del arreglo, (en la posición [0])
       * @param target El elemento a ser agregado
       */
      public void push(E target);
  }
  
  

  
  

• La clase Pila

  package Pila;
  /**
   * @author Daniel Cataño Restrepo
   * @param < E > Dato genérico, este se define en el momento de 
   * crear un objeto de tipo Pila
   */
  public class Pila< e > implements IPila< e >{
  
      //Arreglo en el que se almacenará la información
      E[] data;
      
      /**En el constructor se inicializa el arreglo como un 
      arreglo de objetos vacío con 0 espacios*/
      public Pila(){
          data=(E[])new Object[0];
      }
      
  
      /**Si la longitud del arreglo es 0, entonces el arreglo 
      está vacío*/
      @Override
      public boolean isEmpty() {
          return data.length==0;
      }
      
      /**  ->Crea un arreglo temporal que va a tener
          la dimensión del arreglo data más una posición
          ->Todos los elementos se desplazan una posición
          y el nuevo elemento queda en la posición 0 de temp
          ->Al final se actualiza el arreglo data por temp*/
      @Override
      public void push(E target) {
          E[] temp=(E[])new Object[data.length+1];
          for(int i=data.length-1; i>=0; i--){
              temp[i+1]=data[i];
          }
          temp[0]=target;
          data=temp;
      }
   
      @Override
      public E peek() {
          return data[0];
      }
       
      /**  ->Extrae el primer elemento del arreglo
          ->Crea un arreglo temporal que va a tener 
          la dimensión del arreglo data, menos uno
          ->El elemento en la posición 1 de data va a 
          quedar en la posición 0 del arreglo temp y
          así sucesivamente hasta recorrer todo el
          arreglo data*/
      @Override
      public E pop() {
          E firstElement=data[0];
          E[] temp=(E[])new Object[data.length-1];
          for(int i=0; i < data.length-1; i++)
              temp[i]=data[i+1];
          data=temp;
          return firstElement;
      }
   
      @Override
      public void print() {
          System.out.print("[");
          for(int i=0; i < data.length; i++){
              if(i==data.length-1)
                  System.out.print(data[i]);
              else
                  System.out.print(data[i]+", ");
          }
          System.out.println("]");
      }   
  }
  
  

  
  

• Clase Principal

  package Pila;
  /**
   * @author Daniel Cataño Restrepo
   */
  public class Pilas{   
      public static void main(String[] args) {
         Pila p=new Pila<>();
         /**---------------------------------
          * Se agregan los número del 1 al 7
          * y la cadena de caracteres "abc", etc
          * se pueden agregar números, booleanos y caracteres
          * a la vez gracias a que el tipo de dato es
          * genérico 
          */
         p.push(1);
         p.push(2);
         p.push(3.5);
         p.push(4);
         p.push(5);
         p.push(6);
         p.push(7);
         p.push("abc");
         p.push(false);
         /**Nótese la forma en que los datos
          * fueron ingresados y la posición final
          * que cada uno tomó*/
         p.print();
         /**Se eliminan los 4 primeros datos del 
          arreglo, cada pop() es una eliminación*/
         p.pop();
         p.pop();
         p.pop();
         p.pop();
         p.print();
      }
  }
  
  

  
  

• Resultados

En la siguiente imagen se puede apreciar los resultados arrojados al ejecutar la clase principal, en la primera línea se puede observar como los datos ingresados van empujando a los ya existentes hacia el fondo y en la segunda línea se puede observar cómo se va eliminando de adelante hacia atrás. También es importante notar que al arreglo se le puede agregar todo tipo de dato, entero, flotante, cadenas de caracteres, booleanos, etc, por lo que hay que tener cuidado a la hora de trabajar con ello y crear algún otro programa que sirva para validar el tipo de dato de cada elemento.