Captulo 4.

Pilas
4 Pilas
4.1 Descripcin del TDA Pila. 4.2 Especificacin del TDA Pila.

4.3 Ejemplos de uso.

4.4 Implementaciones del TDA Pila. 4.4.1 Implementacin basada en el TDA Lista.

4.4.2 Implementacin con vectores.

4.4.3 Implementacin con apuntadores. 4.4.4 Comparacin de las implementaciones.

4.1 Descripcin 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 tambin listas LIFO (last-in first-out) o listas primero en entrar, primero en salir. Al igual que ocurra 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 posicin, el tope de la pila.

4.1 Descripcin del TDA Pila

Un TDA de la familia pila incluye a menudo las cinco operaciones siguientes:

CREA. Crea una pila vaca. VACIA. Devuelve un valor cierto si la pila est vaca, y falso en caso contrario. TOPE. Devuelve el elemento situado el tope de la pila, sin extraerlo.

PUSH. Aade un elemento a la pila, quedando ste situado en el tope.

POP. Suprime el elemento situado en el tope de la pila.

4.2 Especificacin del TDA Pila

Especificacin informal del TDA Pila

Pila = TDA con operaciones crea, vacia, tope, push, pop. DESCRIPCIN:

Los valores del TDA Pila son pilas de elementos del tipo Elemento. Las pilas son mutables: push y pop aaden y eliminan elementos en la pila respectivamente.

OPERACIONES:

crea() devuelve (P:Pila)

efecto: Devuelve la pila vaca P

4.2 Especificacin del TDA Pila

vacia(P:Pila) devuelve (booleano)

efecto: Devuelve cierto si P es la pila vaca, y contrario. falso en caso

tope(P:Pila) devuelve (E:Elemento)

requerimientos: La pila P es no vaca. efecto: Devuelve en E el elemento situado en el tope de la pila P

push(P:Pila; E:Elemento)
modifica: P efecto: Aade el elemento E a la pila P, quedando ste situado en el tope.

pop(P:Pila)
requerimientos: La pila P es no vaca. modifica: P efecto: Suprime el elemento situado en el tope de la pila

4.2 Especificacin del TDA Pila

Especificacin Formal Tipo: Pila (Elemento) Sintaxis:

crea Pila vacia(Pila) booleano tope(Pila) Elemento push(Pila,Elemento) Pila pop(Pila) Pila

Semntica: PPila,

EElemento:

vacia(crea) cierto vacia(push(P,E)) falso tope(crea) error tope(push(P,E)) E pop(crea) error pop(push(P,E)) P

4.2 Especificacin del TDA Pila

La interface Java del TDA Pila de acuerdo a esta especificacin 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

4.2 Especificacin 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); }; }

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()

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

4.3 Ejemplos de Uso

import import import import import colaInterface.*; pilaBasadaLista.*; colaException.*; pilaException.*; java.io.*;

class ColaUtil { // mtodos 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); }

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

4.4 Implementaciones del TDA Pila

En esta seccin mostraremos tres implementaciones alternativas para el TDA Pila: 1. Implementacin basada en el TDA Lista; consiste en definir una Pila utilizando una lista 2. Implementacin con vectores; utiliza un array para almacenar los elementos de la Pila 3. Implementacin con apuntadores con representacin con simple enlace

4.4.1 Implementacin 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; } }

4.4.1 Implementacin 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

4.4.2 Implementacin con vectores

Representacin de una pila mediante un vector
0 1

max-3 max-2 max-1

a3 a2 a1

tope = max-3

4.4.2 Implementacin 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); }

4.4.2 Implementacin 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

4.4.2 Implementacin 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); }

4.4.2 Implementacin 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

4.4.2 Comparacin de las implementaciones

De nuevo, los criterios que describimos en un captulo anterior para la comparacin de las implementaciones de listas son tambin vlidos para las implementaciones de pilas. La eleccin de una implementacin u otra depender de los requerimientos de la aplicacin en la que se use. Es posible obtener representaciones para pilas que permiten operaciones eficientes que se realizan en tiempos de ejecucin constantes.