Documentos de Académico
Documentos de Profesional
Documentos de Cultura
TTema 2 Pilas
TTema 2 Pilas
Presentar los TAD lineales pila, cola y secuencia Mostrar la especificacin de cada uno de los TAD lineales Descubrir implementaciones alternativas para cada uno de ellos Ejemplos de aplicacin
Estructuras lineales
Contenidos
1. 2.
3.
TAD Cola
3.1. Especificacin 3.2. Implementacin 3.3. Variantes del TAD Cola 3.4. Aplicaciones
4.
Secuencias
4.1. Secuencias por posicin 4.2. Iteradores
Estructuras lineales
Bibliografa
Goodrich M. y Tamassia R., Data structures and Algorithms in JAVA 4 ed. John Wiley & Sons Inc. , 2006 Pgs.187-203, 204210, 222-228, 231-241, 242-248 Lewis, J. y Chase J. Estructuras de datos con Java. Diseo de estructuras y algoritmos. 2 ed. Pearson. Addisson Wesley. 2006 Pgs. 152-161, 166-174, 180-182, 193-205 Weiss, Mark Allen, Estructuras de datos en Java: compatible con JAVA 2, Addisson Wesley. 2000. Pgs.139-146, 395-410, 415-427 Liskov, B. y J. Guttag, Program Development in Java: Abstraction, Specification, and Object-Oriented Design, AddisonWesley, 2001. Pgs. 125-137
Estructuras lineales
Las estructuras lineales son importantes porque aparecen con mucha frecuencia en situaciones de la vida Ejemplos: Una cola de clientes de un banco, las instrucciones de un programa, los caracteres de una cadena o las pginas de un libro Caractersticas:
existe un nico elemento, llamado primero, existe un nico elemento, llamado ltimo, cada elemento, excepto el primero, tiene un nico predecesor y cada elemento, excepto el ltimo, tiene un nico sucesor crear la estructura vaca, insertar un elemento, borrar un elemento y obtener un elemento
Operaciones:
Para definir claramente el comportamiento de la estructura es necesario determinar en qu posicin se inserta un elemento nuevo y qu elemento se borra o se obtiene. Principales estructuras lineales: pilas, colas y secuencias.
TAD Pila
Contenedor de objetos que son insertados y eliminados de acuerdo con el principio de que el ltimo en entrar es el primero en salir (LIFO - Last In First Out)
Entrar
Salir
Tope de la pila
Los elementos se insertan de uno en uno (push - apilar) Los elementos se sacan en orden inverso al cual se han insertado (pop - desapilar) El nico elemento que se puede observar es el ltimo insertado (tope o cima)
a3 a2 a1
TAD Pila
Especificacin
public class Pila <E> { // caractersticas: // Es una secuencia de elementos donde el ltimo en entrar es el primero en ser eliminado // Los objetos son modificables. public Pila <E> ( ) // Produce: una pila vaca public int tamao() // Produce: devuelve el nmero de elementos de la pila public boolean esVacio() // Produce: cierto si la pila est vaca. Falso en otro caso public E top() throws PilaVaciaExcepcion // Produce: si la pila est vaca lanza la excepcin PilaVaciaExcepcion, // sino devuelve el objeto ms recientemente introducido public E pop() throws PilaVaciaExcepcion // Modifica: this // Produce: si la pila est vaca lanza la excepcin PilaVaciaExcepcion, // sino devuelve el objeto ms recientemente introducido y lo suprime de la pila public void push (E elemento) // Modifica: this // Produce: aade un objeto a la pila, pasando a ser el nuevo tope }
TAD Pila
public class PruebaPila{ public static void main (String []args){ Pila<Integer> p = new Pila<Integer>(); for (int i=1; i<10;i++) p.push(i); System.out.println("Los elementos son: "); while(!p.esVacio()) System.out.println(p.pop()); } }
TAD Pila
Navegadores en Internet almacenan en una pila las direcciones de los sitios ms recientemente visitados. Los editores de texto proporcionan normalmente un botn deshacer que cancela las operaciones de edicin recientes y restablece el estado anterior del documento.
Aplicaciones en programacin
Las pilas son una estructura de datos muy usada como estructura auxiliar en diversos algoritmos y esquemas de programacin. Los casos ms representativos son:
Palndromo, cambio de base, etc Solitario, Laberinto, etc. (back tracking). Evaluacin de expresiones aritmticas, conversin de notaciones (postfija, prefija, infija)... Recursin.
TAD Pila
public class ArrayPila<E> implements Pila<E> public class EnlazadaPila<E> implements Pila<E>
Mediante
TAD Pila
public class PilaVaciaExcepcion extends RuntimeException{ public PilaVaciaExcepcion (){ super(); } public PilaVaciaExcepcion (String mensaje){ super(mensaje); } }
TAD Pila
Representacin
elementos Tope de la pila
a1
0
a2
1
a3
2
a4
3
...
at
tope N-1
public class ArrayPila<E> implements Pila<E>{ public static final int CAPACIDAD_POR_DEFECTO=10; private E [] elementos; private int tope;
Ventaja: todas las operaciones tienen coste temporal constante O(1) Problema: pila llena Solucin:
mtodo privado duplicarPila() -> expansin dinmica del vector un nuevo tipo de excepcin, PilaLlenaExcepcion
TAD Pila
Representacin
Tope de la pila
public class EnlazadaPila<E> implements Pila<E> { private Nodo<E> tope; private int contador;
Ventajas:
todas las operaciones tienen coste temporal constante O(1) no hay limitaciones de tamao
TAD Pila
public class Nodo<E> { private E elemento; private Nodo<E> sig; //referencia al elemento del nodo //referencia al siguiente nodo de la lista
public Nodo(){ //Produce: crea un nodo con valor null en sus referencias al elemento y al siguiente nodo this(null,null); } public Nodo(E e, Nodo<E> n){ // Produce: un objeto Nodo con el elemento y siguiente nodo que se le pasa como parmetro elemento=e; sig=n; } public void setElemento(E e){ // Modifica: this // Produce: modifica el atributo elemento de this elemento = e; } public void setSig(Nodo<E> n){ // Modifica: this // Produce: modifica el atributo sig de this sig = n; } public E getElemento(){ // Produce: devuelve el atributo elemento de this return elemento; } public Nodo<E> getSig(){ // Produce: devuelve el atributo sig de this return sig; } }
TAD Pila
public class EnlazadaPila<E> implements Pila<E> { private Nodo<E> tope; private int contador; public EnlazadaPila(){ tope=null; contador=0; } public int tamao(){ return contador; } public boolean esVacio(){ return tope==null; } public E top() throws PilaVaciaExcepcion{ if (esVacio()) throw new PilaVaciaExcepcion("top: Pila Vacia"); return tope.getElemento(); } public void push (E e){ Nodo<E> n=new Nodo<E>(e,tope); tope=n; contador++; } public E pop() throws PilaVaciaExcepcion{ if (esVacio()) throw new PilaVaciaExcepcion("pop: Pila Vacia"); E e=tope.getElemento(); tope=tope.getSig(); contador--; return e; } }
TAD Pila
public interface Pila<E>{ public int tamao(); public boolean esVacio(); public E top() throws PilaVaciaExcepcion; public void push (E elemento); public E pop() throws PilaVaciaExcepcion; }
public class PilaVaciaExcepcion{ public PilaVaciaExcepcion(){ } public PilaVaciaExcepcion(String mensaje){ } }
public class ArrayPila<E> implements Pila<E>{ public static final int CAPACIDAD_POR_DEFECTO=10; private E [] elementos; private int tope; public ArrayPila(){ // inicializa los atributos de la representacin } //implementacin operaciones de la interfaz }
public class EnlazadaPila<E> implements Pila<E>{ private Nodo<E> tope; private int contador; public EnlazadaPila(){ // inicializa los atributos de la representacin } //implementacin operaciones de la interfaz }
public class Nodo<E>{ private E elemento; private Nodo<E> sig; public Nodo(){ --} //resto operaciones }