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 falso en caso
contrario.

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 colaInterface.*;
import pilaBasadaLista.*;
import colaException.*;
import pilaException.*;
import 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
a
3
max-3
tope = max-3
a
2
max-2
a
1
max-1
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.