PILAS Y COLAS

Pila 

Es una estructura de datos en la que el modo de acceso a sus elementos es de tipo LIFO(ultimo en entrar,primero en salir).

Operaciones de la Pila 

Las operaciones que se pueden realizar con una pila son: 

• Push(pila,elemento)Introduce un elemento a 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.
• Vaciar,función booleana que indica si la pila esta vacía o no.

Cola 

Es una estructura de datos, caracterizada por ser una secuencia de elementos en la que la operación de inserción push se realiza por un extremo y la operación de extracción pop por el otro. También se le llama estructura FIFO (primero en entrar,primero en salir). 

Operaciones de la cola 

Las operaciones que se pueden realizar en una cola son: 

• Encolar(añadir,entrar,insertar)Se añade un elemento a la cola,se añade al final de esta.
• Desencolar(sacar,salir,eliminar)Se elimina el elemento frontal de la cola es decir el primer elemento que entro.

Comparación entre Pilas y Colas 
 Pilas:

•  En las Pilas se puede acceder a los elementos de la lista solo a través de la cima de la misma.
• Se puede acceder a los elementos de la Pila solo a través del sistema LIFO. 
• Se considera como una estructura de datos Las In Fist Out.
•  Solo se puede agregar elementos a la parte superior de la Pila. 

Colas: 

• Se pude acceder a los elementos de la lista desde cualquier extremo de la misma, ya sea desde el comienzo o desde el final.
•  Los elementos se eliminan de la Cola en el orden de llegada. 
• Se considera como una estructura First In First Out. 
• En las bi-colas se pueden agregar elementos desde ambos extremos de la lista, ya sea desde el comienzo o desde el final.

 Ejemplo:

A continuación se mostrara un algoritmo sobre pilas y colas Primero se crea una clase nodo para la pila

public class Nodo {
    //Datos que se guardara en el Nodo
    private Object valor;
    //Referencia al nodo siguiente
    private Nodo siguiente;
    
    //Constructor. Recibe el dato a guardar y el nodo siguiente
    public Nodo(Object val,Nodo sig){
        this.valor = val;
        this.siguiente = sig;
    }
    
    //Getters y Setters para tomar y cambiar valores.
    public Object getValor() {
        return valor;
    }

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

    public Nodo getSiguiente() {
        return siguiente;
    }

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

Ahora creamos nuestra clase arreglo

public class Arreglo {
    //Creamos dos Nodos, que seran el primero y el ultimo nodo de nuestro arreglo
    private Nodo primero,ultimo;
    private int tamaño;
    
    //Constructor. Inicializacion de las variables
    public Arreglo(){
        ultimo = primero = null;
        tamaño = 0;
    }
    
    //Funcion que inserta un dato al principio del arreglo, recibe como parametro el dato a insertar
    public void insertarPrimero(Object valor){
        if(tamaño == 0){
            primero = new Nodo(valor,null);
            ultimo = primero;
            tamaño++;
        }
        else{
            Nodo temporal = primero;
            primero = new Nodo(valor,temporal);
            tamaño++;
        }
    }
    
    //Funcion que inserta un dato al final del arreglo recibe como parametro el dato a insertar
    public void insertarUltimo(Object valor){
        if(tamaño == 0){
            primero = new Nodo(valor,null);
            ultimo = primero;
            tamaño++;
        }
        else{
            Nodo temporal = ultimo;
            ultimo = new Nodo(valor, null);
            temporal.setSiguiente(ultimo);
            tamaño++;
        }
    }
    
    //Funcion que elimina el primer nodo del arreglo
    public void eliminarPrimero(){
        if(tamaño == 0)return;
        Nodo temporal = primero;
        temporal = primero.getSiguiente();
        primero = null;
        primero = temporal;
        tamaño--;
    }
    
    //Funcion que elimmina el ultimo nodo del arreglo
    public void eliminarUltimo(){
        if(tamaño == 0)return;
        if(tamaño == 1){
            ultimo = primero = null;
            tamaño = 0;
            return;
        }
        Nodo temporal = primero;
        while(temporal.getSiguiente() != ultimo){
            temporal = temporal.getSiguiente();
        }
        temporal.setSiguiente(null);
        ultimo = temporal;
        tamaño--;
    }
    
    
    public int getTamaño(){
        return tamaño;
    }
    

    public Object[] getElementos(){
        if(tamaño == 0)return new Object[0];
        Object[] elementos = new Object[tamaño];
        int i = 0;
        Nodo temporal = primero;
        while(temporal != null){
            System.out.print(temporal.getValor().toString()+"  ");
            elementos[i++] = temporal.getValor();
            temporal = temporal.getSiguiente();
        }
        System.out.println("");
        return elementos;
    }
    
    public static void main(String[] args) {
        Arreglo lista = new Arreglo();
        lista.insertarPrimero(1);
    }
    
}

Creamos nuestra clase pila

public class Pila {
    //Declaramos una variable tipo Arreglo
    private Arreglo pila;
    
    //Contructor. Inicializacion del arreglo
    public Pila(){
        pila = new Arreglo();
    }
    
    //Funcion que inserta un elemento a la pila
    public void push(Object dato){
        pila.insertarPrimero(dato);
    }
    
    //Funcion que elimina un elemento de la pila
    public Object pop(){
        Object Dato = pila.getElementos()[0];
        pila.eliminarPrimero();
        return Dato;
    }
    
    //Funcion que devuelve el tope de la pila
    public Object peek(){
        return pila.getElementos()[0];
    }
    
    //Funcion que devueleve el tamaño de la pila
    public int size(){
        return pila.getTamaño();
    }
    
    //Funcion que devuelve los elementos de la pila
    public Object[] getElementos(){
        return pila.getElementos();
    }
}

Creamos nuestra clase cola

public class Cola {
    private Arreglo cola;
    
    public Cola(){
        cola = new Arreglo();
    }
    
    public void encolar(Object dato){
        cola.insertarUltimo(dato);
    }
    
    public Object desencolar(){
        Object dato = cola.getElementos()[0];
        cola.eliminarPrimero();
        return dato;
    }
    
    public Object frente(){
        return cola.getElementos()[0];
    }
    
    public int size(){
        return cola.getTamaño();
    }
    
    public Object[] getElementos(){
        return cola.getElementos();
    }
    
}