Pilas

Estructura (lineal) compleja que toma una estructura más simple como los arreglos y las listas, y restringe sus operaciones de tal manera que se cumpla la regla (LIFO) último dato en llegar, primero en quitar. Se usa cuando se requiere retroceder en puntos pendientes en el procesamiento de datos.

UTILIDAD: RETROCEDER, INVERTIR EN PROCESOS CON TAREAS PENDIENTES POR COMPLETAR.

APLICACIONES: LLAMADO A SUBPROGRAMAS, EVALUACION DE EXPRESIONES ARITMETICAS.

OPERACIONES: PONER Y QUITAR.

IMPLEMENTACION: VECTORES, LISTAS ENLAZADAS
max
 tope
 Poner {Tope++ , v[Tope]= dato
 Quitar{dato=v[Tope], tope--
 En listas enlazadas, poner es insertar un nuevo nodo y quitar es eliminar un nuevo nodo.

Funciones para:

1. Eliminar el primer elemento

2. Intercambiar elementos de extremos

3. Invertir elementos

4. Eliminar elementos especificos

5. Eliminar elementos repetidos en forma consecutiva

6. Hacer una copia de una pila

public class Pila <T>{
    private T v[];
    private int tope, max;
    public Pila(){
        max = 100;
        v = (T[]) new Object[max];
        tope = -1;
    }
    public Pila(int max){
        this.max = max;
        v = (T[]) new Object[max];
        tope = -1;
    }
    public boolean vacia(){
        return tope == -1;
    }
    public boolean llena(){
        return tope == max-1;
    }
    public void poner(T dato){
        if(!llena())
           v[++tope] = dato;
        else
           System.out.println("Pila Llena...!");
    }
    public T quitar(){
        T dato = null;
        if(!vacia())
           dato = v[tope--];
        else
           System.out.println("Pila Vacía...!");
        return dato;
    }
    public T cima(){
     if(!vacia())
        return v[tope];
     else
        return null;   
    } 
}

5.

Public class Principal{

  public static void main(String... arg){

     Pila<Sring> nombres = new Pila<>();

       p.poner("x");

       p.poner("y");

       p.poner("y");

       p.poner("z");

       p.poner("y");

       eliminarConsecutivo(nombres);

        while(!nombres.vacia()){

          sop(nombres.quitar());

        }

   }

public void eliminarConsecutivo(Pila p){

      Pila q = new Pila();

     if(!p.vacia()){

      q.poner(p.quitar());

}else{

sop("Esta vacia");

       while(!p.vaciaa()){

       if(!p.cima().equals(q.cima()){

         q.poner(p.quitar());

     }else{

        p.quitar();

}

while(!q.vacia()){

  p.poner(q.quitar());

}

}

}