capítulo 4. pilas

Capítulo 4. PilasCapítulo 4. Pilas

4 Pilas4 Pilas

4.1 4.1 Descripción del TDA Pila.Descripción del TDA Pila.

4.24.2 Especificación del TDA Pila. Especificación del TDA Pila.

4.34.3 Ejemplos de uso. Ejemplos de uso.

4.44.4 Implementaciones del TDA Pila. Implementaciones del TDA Pila.

4.4.14.4.1 Implementación basada en el TDA Lista. Implementación basada en el TDA Lista.

4.4.24.4.2 Implementación con vectores. Implementación con vectores.

4.4.3 4.4.3 Implementación con apuntadores.Implementación con apuntadores.

4.4.4 4.4.4 Comparación de las implementaciones.Comparación de las implementaciones.

4.1 Descripción del TDA Pila4.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.

4.1 Descripción del TDA Pila4.1 Descripción del TDA Pila

Un TDA de la familia pila incluye a menudo las cincooperaciones 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.2 Especificación del TDA Pila4.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


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


Especificación Formal Tipo: Pila (Elemento) Sintaxis:

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

Semántica: 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


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


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 Uso4.3 Ejemplos de Usoimport 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 Uso4.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


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


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 Pila4.4 Implementaciones del TDA Pila

En esta sección mostraremos tres implementaciones alternativas para el TDA Pila:

1. Implementación basada en el TDA Lista; consiste en definir una Pila utilizando una lista

2. Implementación con vectores; utiliza un array para almacenar los elementos de la Pila

3. Implementación con apuntadores con representación con simple enlace

4.4.1 Implementación basada en el TDA Lista4.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; } }

4.4.1 Implementación basada en el TDA Lista4.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

4.4.2 Implementación con vectores4.4.2 Implementación con vectores

Representación de una pila mediante un vector

0

1

a3max-3

tope = max-3

a2max-2

a1max-1


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


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 Implementación con apuntadores4.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); }

4.4.2 Implementación con apuntadores4.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

4.4.2 Comparación de las implementaciones4.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.

capítulo 4. pilas

Documents