Capítulo 4. Pilas

1. Capítulo 4. Pilas 4 Pilas 4.1 Descripción del TDA Pila. 4.2 Especificación del TDA Pila. 4.3 Ejemplos de uso. 4.4 Implementaciones del TDA Pila. 4.4.1 Implementación basada en el TDA Lista. 4.4.2 Implementación con vectores. 4.4.3 Implementación con apuntadores. 4.4.4 Comparación de las implementaciones.

2. 4.1 Descripción del TDA Pila • Una  pila es un caso especial de lista en la cual todas las inserciones y supresiones tienen lugar en un extremo determinado llamado tope. • A las pilas se les llama también listas LIFO(last-in first-out) o listas “primero en entrar, primero en salir”. • Al igual que ocurría con el TDA Cola, en el TDA Pila tampoco se definen operaciones de posicionamiento en la pila. Esto es debido a que todas las operaciones de acceso se realizan en la misma posición, el tope de la pila.

3. 4.1 Descripción del TDA Pila Un TDA de la familia pila incluye a menudo las cinco operaciones siguientes: • CREA. Crea una pila vacía. • VACIA. Devuelve un valor cierto si la pila está vacía, y falso en caso contrario. • TOPE. Devuelve el elemento situado el tope de la pila, sin extraerlo. • PUSH. Añade un elemento a la pila, quedando éste situado en el tope. • POP. Suprime el elemento situado en el tope de la pila.

4. 4.2 Especificación del TDA Pila Especificación informal del TDA Pila • Pila = TDA con operaciones crea, vacia, tope, push, pop. • DESCRIPCIÓN: • Los valores del TDA Pila son pilas de elementos del tipo Elemento. Las pilas son mutables: push y pop añaden y eliminan elementos en la pila respectivamente. • OPERACIONES: • crea() devuelve (P:Pila) • efecto: Devuelve la pila vacía P

5. 4.2 Especificación del TDA Pila • vacia(P:Pila) devuelve (booleano) • efecto: Devuelve cierto si P es la pila vacía, y falso en caso contrario. • tope(P:Pila) devuelve (E:Elemento) • requerimientos: La pila P es no vacía. • efecto: Devuelve en E el elemento situado en el tope de la pila P • push(P:Pila; E:Elemento) • modifica: P • efecto: Añade el elemento E a la pila P, quedando éste situado en el tope. • pop(P:Pila) • requerimientos: La pila P es no vacía. • modifica: P • efecto: Suprime el elemento situado en el tope de la pila

6. 4.2 Especificación del TDA Pila Especificación Formal • Tipo:Pila (Elemento) • Sintaxis: • crea  Pila • vacia(Pila)  booleano • tope(Pila)  Elemento • push(Pila,Elemento)  Pila • pop(Pila)  Pila • Semántica: PPila, EElemento: • vacia(crea)  cierto • vacia(push(P,E))  falso • tope(crea)  error • tope(push(P,E))  E • pop(crea)  error • pop(push(P,E))  P

7. 4.2 Especificación del TDA Pila La interface Java del TDA Pila de acuerdo a esta especificación puede definirse de la siguiente forma: package pilaInterface; import pilaException.*; public interface Pila {     public boolean vacia();     public Object tope() throws PilaVaciaException;     public void push(Object elemento);     public void pop() throws PilaVaciaException; }  // fin interface Pila

8. 4.2 Especificación del TDA Pila Las excepciones para Cola: package pilaException; public class PilaException extends Exception {     public PilaException() { super(); };     public PilaException(String s) { super(s); }; } package pilaException; public class PilaVaciaException extends PilaException {     public PilaVaciaException() { super(); };     public PilaVaciaException(String s) { super(s); };   }

9. 4.3 Ejemplos de Uso import pilaInterface.*; import pilaException.*; import java.io.*; public class PilaUtil {    static public void imprimir(Pila pila) {         try { Pila pilaAux = duplicar(pila);             while (!pilaAux.vacia()) {                 Object e = pilaAux.tope(); pilaAux.pop();                 System.out.print(e+" ");             }             System.out.println(); } catch (PilaException e) {             System.err.println("Error en el uso de la Pila: "+e);         }     } // fin imprimir()

10. 4.3 Ejemplos de Uso static public Pila duplicar(Pila pila) {         try {             Pila pila2 = (Pila)pila.getClass().newInstance();             Pila pilaAux = (Pila)pila.getClass().newInstance();             while (!pila.vacia()) {                 Object e = pila.tope(); pila.pop(); pilaAux.push(e);             }             while (!pilaAux.vacia()) {                 Object e = pilaAux.tope(); pilaAux.pop();                 pila.push(e); pila2.push(e); }             return pila2;         } catch (PilaException e) { System.err.println("Error en el uso de la Pila: "+e); } catch (Exception e) { System.err.println(e); }         return null;     } // fin duplicar() } // fin class PilaUtil

11. 4.3 Ejemplos de Uso import colaInterface.*; import pilaBasadaLista.*; import colaException.*; import pilaException.*; import java.io.*; class ColaUtil {     // métodos de la clase ColaUtil     static public Cola invertir(Cola cola) { try {             Pila pilaAux = new Pila(); Cola colaAux = duplicar(cola);             while(!colaAux.vacia()) {                 Object e = colaAux.primero();                 colaAux.suprime();                 pilaAux.push(e);             }

12. 4.3 Ejemplos de Uso             Cola cola2 = (Cola)cola.getClass().newInstance();             while(!pilaAux.vacia()) {                 Object e = pilaAux.tope();                 pilaAux.pop();                 cola2.inserta(e); }             return cola2;         } catch (ColaException e) { System.err.println("Error en el uso de la Cola: "+e);         } catch (PilaException e) {             System.err.println("Error en el uso de la Pila: "+e); } catch (Exception e) {             System.err.println(e);         }         return null; } } // fin class ColaUtil

13. 4.4 Implementaciones del TDA Pila En esta sección mostraremos tres implementaciones alternativas para el TDA Pila: • Implementación basada en el TDA Lista; consiste en definir una Pila utilizando una lista • Implementación con vectores; utiliza un array para almacenar los elementos de la Pila • Implementación con apuntadores con representación con simple enlace

14. 4.4.1 Implementación basada en el TDA Lista package pilaBasadaLista; import pilaException.*; import listaException.*; import listaSimpleEnlazada.*; public class Pila implements pilaInterface.Pila {     private Lista lista;     public Pila() {         lista = new Lista();     }     public boolean vacia() {         return lista.vacia();     }     public Object tope() throws PilaVaciaException {         if (vacia()) throw new PilaVaciaException(); try {             return lista.recupera(lista.primero());         } catch (ListaException e) {             System.err.println("Error interno de la Pila: "+e); return null;         }     }

15. 4.4.1 Implementación basada en el TDA Lista     public void push(Object elemento) { try { if (vacia()) lista.inserta(lista.fin(),elemento); else lista.inserta(lista.primero(),elemento);         } catch (ListaVaciaException e) {             System.err.println("Error interno de la Pila"); }     }     public void pop() throws PilaVaciaException{         if (vacia()) throw new PilaVaciaException(); try {             lista.suprime(lista.primero()); } catch (ListaException e) { System.err.println("Error interno de la Pila");         }     } }  // fin class Pila

16. 0 1 max-3 max-2 max-1 a3 a2 a1 tope = max-3 4.4.2 Implementación con vectores Representación de una pila mediante un vector

17. 4.4.2 Implementación con vectores package pilaContigua; import pilaException.*; public class Pila implements pilaInterface.Pila {     private static int max = 100;     private Object elementos[];     private int tope;     public Pila() {         elementos = new Object[max];         tope=max;     }     public boolean vacia() {         return (tope==max);     }

18. 4.4.2 Implementación con vectores     public Object tope() throws PilaVaciaException {         if (vacia()) throw new PilaVaciaException();         return elementos[tope];     }     public void push(Object elemento) { tope--;         elementos[tope]=elemento; }     public void pop() throws PilaVaciaException{         if (vacia()) throw new PilaVaciaException(); tope++;     } }  // fin class Pila

19. 4.4.2 Implementación con apuntadores package pilaSimpleEnlazada; import pilaException.*; public class Pila implements pilaInterface.Pila {     class Celda {         Object elemento; Celda sig;     }     private Celda pila; public Pila() {         pila = null;     }     public boolean vacia() {         return (pila==null);     }

20. 4.4.2 Implementación con apuntadores     public Object tope() throws PilaVaciaException {         if (vacia()) throw new PilaVaciaException();         return pila.elemento;     }     public void push(Object elemento) { Celda aux = new Celda();         aux.elemento = elemento;         aux.sig = pila; pila = aux;     }     public void pop() throws PilaVaciaException{         if (vacia()) throw new PilaVaciaException(); pila = pila.sig;     } }  // fin class Pila

21. 4.4.2 Comparación de las implementaciones • De nuevo, los criterios que describimos en un capítulo anterior para la comparación de las implementaciones de listas son también válidos para las implementaciones de pilas. • La elección de una implementación u otra dependerá de los requerimientos de la aplicación en la que se use. • Es posible obtener representaciones para pilas que permiten operaciones eficientes que se realizan en tiempos de ejecución constantes.