Estructuras lineales, descargado de internet

1. Estructuras lineales
Presentar los TAD lineales pila, cola y secuencia
Mostrar la especificación de cada uno de los TAD lineales
Descubrir implementaciones alternativas para cada uno de ellos
Ejemplos de aplicación

2. AEDI – I.T. Informática de Gestión – Curso 09/10
Estructuras lineales
Contenidos
1. Introducción
2. TAD Pila
2.1. Especificación
2.2. Implementación
2.3. Aplicaciones
3. TAD Cola
3.1. Especificación
3.2. Implementación
3.3. Variantes del TAD Cola
3.4. Aplicaciones
4. Secuencias
4.1. Secuencias por posición
4.2. Iteradores

3. AEDI – I.T. Informática de Gestión – Curso 09/10
Estructuras lineales
Bibliografía
Goodrich M. y Tamassia R., Data structures and Algorithms in
JAVA 4ª ed. John Wiley & Sons Inc. , 2006 Págs.187-203, 204-
210, 222-228, 231-241, 242-248
Lewis, J. y Chase J. Estructuras de datos con Java. Diseño de
estructuras y algoritmos. 2ª ed. Pearson. Addisson Wesley. 2006
Págs. 152-161, 166-174, 180-182, 193-205
Weiss, Mark Allen, Estructuras de datos en Java: compatible
con JAVA 2, Addisson Wesley. 2000. Págs.139-146, 395-410,
415-427
Liskov, B. y J. Guttag, Program Development in Java:
Abstraction, Specification, and Object-Oriented Design, Addison-
Wesley, 2001. Págs. 125-137

4. AEDI – I.T. Informática de Gestión – Curso 09/10
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 páginas de un libro
Características:
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
Operaciones:
crear la estructura vacía,
insertar un elemento,
borrar un elemento y
obtener un elemento
Para definir claramente el comportamiento de la estructura es necesario determinar
en qué posición se inserta un elemento nuevo y qué elemento se borra o se
obtiene.
Principales estructuras lineales: pilas, colas y secuencias.

5. AEDI – I.T. Informática de Gestión – Curso 09/10
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)
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)
Entrar Salir
a1
a2
a3
Tope de
la pila

6. AEDI – I.T. Informática de Gestión – Curso 09/10
TAD Pila
Especificación
public class Pila <E> {
// características:
// 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 vacía
public int tamaño()
// Produce: devuelve el número de elementos de la pila
public boolean esVacio()
// Produce: cierto si la pila está vacía. Falso en otro caso
public E top() throws PilaVaciaExcepcion
// Produce: si la pila está vacía lanza la excepción PilaVaciaExcepcion,
// sino devuelve el objeto más recientemente introducido
public E pop() throws PilaVaciaExcepcion
// Modifica: this
// Produce: si la pila está vacía lanza la excepción PilaVaciaExcepcion,
// sino devuelve el objeto más recientemente introducido y lo suprime de la pila
public void push (E elemento)
// Modifica: this
// Produce: añade un objeto a la pila, pasando a ser el nuevo tope
}

7. AEDI – I.T. Informática de Gestión – Curso 09/10
TAD Pila
Ejemplo de uso del 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());
}
}

8. AEDI – I.T. Informática de Gestión – Curso 09/10
TAD Pila
Aplicaciones en la vida real:
Navegadores en Internet almacenan en una pila las direcciones
de los sitios más recientemente visitados.
Los editores de texto proporcionan normalmente un botón
deshacer que cancela las operaciones de edición recientes y
restablece el estado anterior del documento.
Aplicaciones en programación
Las pilas son una estructura de datos muy usada como
estructura auxiliar en diversos algoritmos y esquemas de
programación. Los casos más representativos son:
Palíndromo, cambio de base, etc
Solitario, Laberinto, etc. (back tracking).
Evaluación de expresiones aritméticas, conversión de notaciones
(postfija, prefija, infija)...
Recursión.

9. AEDI – I.T. Informática de Gestión – Curso 09/10
TAD Pila
Implementación del TAD Pila
Paso 1: Definición interfaz
public interface Pila<E>{
public int tamaño();
public boolean esVacio();
public E top() throws PilaVaciaExcepcion;
public void push (E elemento);
public E pop() throws PilaVaciaExcepcion;
}
Paso 2: Clase implemente la interfaz
Mediante arrays
public class ArrayPila<E> implements Pila<E>
Mediante listas enlazadas genéricas
public class EnlazadaPila<E> implements Pila<E>

10. AEDI – I.T. Informática de Gestión – Curso 09/10
TAD Pila
public class PilaVaciaExcepcion extends RuntimeException{
public PilaVaciaExcepcion (){
super();
}
public PilaVaciaExcepcion (String mensaje){
super(mensaje);
}
}

11. AEDI – I.T. Informática de Gestión – Curso 09/10
TAD Pila
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
Solución:
método privado duplicarPila() -> expansión dinámica del vector
un nuevo tipo de excepción, PilaLlenaExcepcion
elementos
Tope de
la pila
a1 a2 a3 a4 ... at
0 1 2 3 tope N-1
Representación

12. AEDI – I.T. Informática de Gestión – Curso 09/10
TAD Pila
Representación
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 tamaño
Tope de
la pila

13. AEDI – I.T. Informática de Gestión – Curso 09/10
TAD Pila
public class Nodo<E> {
private E elemento; //referencia al elemento del nodo
private Nodo<E> sig; //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 parámetro
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;
}
}

14. AEDI – I.T. Informática de Gestión – Curso 09/10
TAD Pila
public class EnlazadaPila<E> implements Pila<E> {
private Nodo<E> tope;
private int contador;
public EnlazadaPila(){
tope=null;
contador=0;
}
public int tamaño(){
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;
}
}

15. AEDI – I.T. Informática de Gestión – Curso 09/10
TAD Pila
public interface Pila<E>{
public int tamaño();
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 representación
}
//implementación 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 representación
}
//implementación operaciones de la interfaz
}
public class Nodo<E>{
private E elemento;
private Nodo<E> sig;
public Nodo(){
---
}
//resto operaciones
}