LISTAS, PILAS Y COLAS

Transcripción

1 1 LISTAS, PILAS Y COLAS Muchos algoritmos requieren una representación apropiada de los datos para lograr ser eficientes Esta representación junto con las operaciones permitidas se llama Estructura de Datos Casi todas permiten inserciones arbitrarias Varían en como permiten el acceso a los miembros Algunas permiten acceso y borrado arbitrarios Otras imponen restricciones tales como acceso al elemento más recientemente insertado o al menos recientemente insertado Por qué se necesitan estructuras de datos? Permiten la reutilización de componentes: Se definen interfaces simples con las operaciones disponibles y las diversas aplicaciones pueden utilizarlas sin tener en cuenta su implementación Todas las estructuras son fáciles de implementar si no se tiene en cuenta el rendimiento: Se pueden colocar componentes baratas en la fase de depuración y luego se pueden reemplazar por implementaciones con mejor rendimiento en tiempo y/o espacio Cuadro comparativo de Estructuras de Datos Estructura de Datos Acceso Comentarios Pilas Sólo el más reciente cima, O(1) Muy rápidas Colas Sólo el menos reciente quitarprimero, O(1) Muy rápidas Listas enlazadas Cualquier momento O(N) Arboles de búsqueda Tablas hash Colas de prioridad Cualquier momento por nombre o rango. O(log N) Cualquier momento por nombre O(1) buscarmin, O(1) eliminarmin, O(log N) Caso medio, también en el peor caso Casi seguro Insertar es O(1) en promedio, O(log N) en el peor. LISTAS ENLAZADAS Listas enlazadas simples DEFINICIÓN: OPERACIONES BÁSICAS: Crear Insertar un elemento Borrar un elemento Es un secuencia ordenada de nodos, donde cada nodo conoce a su nodo sucesor. OTRAS DE UTILIDAD: Longitud de una lista Determinación de igualdad de dos listas Etc.

2 2 OPERACIONES CON LISTAS ENLAZADAS Recorrido: Esta operación consiste en visitar cada uno de los nodos que forman la lista Inserción: Esta operación consiste en agregar un nuevo nodo a la lista. Se pueden considerar tres casos: * Insertar un nodo al inicio * Insertar un nodo antes o después de cierto nodo. * Insertar un nodo al final. Borrado: La operación de borrado consiste en quitar un nodo de la lista, redefiniendo las ligas que correspondan. Se pueden presentar cuatro casos: * Eliminar el primer nodo. * Eliminar el último nodo. * Eliminar un nodo con cierta información. *Eliminar el nodo anterior o posterior al nodo cierta con inf. Búsqueda: Esta operación consiste en visitar cada uno de los nodos, hasta ubicar un nodo con determinada característica, devolviendo su posición ESPECIFICACION DE LISTAS ENLAZADAS SIMPLES Especificación Modelo: Para poder representar esta estructura se consideran las clases SNode : que representa un nodo de la lista. SList : representa la secuencia ordenada de nodos. La clase SNode tiene dos atributos : valor : es el valor del nodo. value siguiente : es una referencia al nodo sucesor. next La clase SList, simplemente tiene un único atributo que representa el primer nodo de la lista, los restantes nodos se pueden conocer por la referencia al sucesor. Protocolo de mensajes Los mensajes que debería responder un nodo podrían ser: valor : retorna el valor del nodo. siguiente : retorna el nodo sucesor Los mensajes que debería responder una lista podrían ser: longitud : retorna la longitud de la lista. agregarelemento : agrega un elemento a la lista. borrarelemento : elimina un nodo de la lista. Se puede implementar el protocolo de mensajes de una lista en un nodo, pero no es correcto desde el punto de vista de objetos, por que un nodo es parte de una lista y la clase Lista utiliza los servicios que da la clase Nodo para poder implementar sus métodos. Interfaz Está incompleta Faltan las operaciones de eliminación: Eliminar primero, eliminar el siguiente de un nodo objeto

3 3 Implementación de Nodo class SNode { Object value; next; SNode SNode() { value = null; next = null; SNode(Object avalue) { value = avalue; next = null; public SNode next() { return next; public void next(snode nextnode) { next = nextnode; Clase Lista Simple import SNode; class SList {SNode firstnode; SList() { firstnode = null; public void addelement(object value) { if(firstnode == null) firstnode = new SNode(value); else { SNode aux = firstnode; while(aux.next()!= null) aux = aux.next(); aux.next(new SNode(value)); public int size() { int size = 0; SNode aux = firstnode; while(aux!= null) { aux = aux.next(); size ++; return size; public Object elementat(int index) { if((index <= size()) && (index > 1)) { SNode aux = firstnode; while(index > 1) { aux = aux.next(); index ; return aux.value(); else return null;

4 4 public boolean equals(slist alist) { if(size() == alist.size()) {int index = 1; SNode aux = firstnode; boolean equals = true; while((aux!= null) && equals) {if((alist.elementat(index)).equals(aux.value()) ) {index ++; aux = aux.next(); else equals = false; return equals; return false; public boolean contains(object aobject) { SNode aux = firstnode; While ((aux!= null) && (! aobject.equals(aux.value()))) aux = aux.next(); if( aux == null) return false; else return true; public Object firstelement() { return firstnode.value(); public Object lastelement() { SNode aux = firstnode; while(aux.next!= null) aux = aux.next(); return aux.value(); Ver que quien lo invoca verificará que la lista no sea vacía public void atput(int index,object value) { if((index > 0) & (index <= size())) { SNode aux = firstnode; for(int i = 0; i < index; i++) aux = aux.next(); SNode newnode = new SNode(value); if( aux.next()!= null) newnode.next(aux.next()); aux.next(newnode); Notar que si en Snode se dispone un constructor que inicia los dos atributos directamente, la parte marcada puede codificarse como: aux.next (new Snode ( value, aux.next))

5 5 PILAS Estructura de datos en la cual el acceso está limitado al elemento más recientemente insertado El último elemento añadido a la pila es colocado en la cima, donde es accedido directamente, mientras que los elementos que llevan más tiempo son más difíciles de acceder Operaciones naturales: insertar (apilar) eliminar (desapilar) buscar (cima) Puede ser utilizada para dar vuelta a una lista de elementos Estructura LIFO: Last In, First Out (último en entrar, primero en salir) Interfaz pila: Métodos principales Object pop() :Elimina el elemento en la cima de la pila y devuelve el objeto que contiene void push(object elem) :Inserta un elemento en la cima de la pila Métodos auxiliares Object top() boolean isempty() int size() :Devuelve el elemento que hay en la cima de la pila sin eliminarlo de la misma. :Devuelve true si la pila está vacía y false en caso contrario :Devuelve el tamaño de la pila Implementación basada en Arrays public class ArrayStack implements Stack { //comienzo de la clase public static final int CAP=1000; private int capacity; private Object S[]; private int top=1; public ArrayStack(){this(CAP); public ArrayStack(int cap){ capacity=cap; S=new Object[capacity]; public int size() {return (top+1); public boolean isempty() {return (top<0); public Object top()throws StackEmptyException{ if (isempty()) throw new StackEmptyException("vacio"; return S[top]; public void push(object o) throws StackFullException { if (size()==capacity) throw new StackFullException("lleno"); S[++top]=o; public Object pop() throws StackEmptyException { Object el; if (isempty()) throw new StackEmptyException("vacio"; el=s[top]; S[top]=null; return el; //fin de la clase

6 6 Interfaz: Una Pila se puede definir como una subclase de la clase SList Para esta implementación se deberían redefinir los métodos heredados para dar el comportamiento adecuado Implementación alternativa: se utiliza el concepto de agregación. Jerarquía de clases de una Pila Implementación basada en Listas class Stack { SList list; Stack() { list = new SList(); public void push(object aobject) { list.addelement(aobject); public boolean isempty() { return list.isempty(); public Object pop() { if (! isempty()) { Object re = list.lastelement(); list.removeelement(re); return re; else return null; Cada operación debería tardar una cantidad constante de tiempo en ejecutarse, independientemente del número de elementos apilados ( Ej: Tomar el diario de hoy en una pila). Además es de O(1) ALGUNAS APLICACIONES DE PILAS: En COMPILADORES ( Análisis sintáctico de lenguajes de programación) Análisis de símbolos equilibrados Implementación de llamadas a procedimientos Evaluación de expresiones precedencia de operadores Análisis sintáctico I Símbolos equilibrados con posibles de anidamientos : ( ), begin end 1 Construir pila vacía 2 Leer símbolo hasta el final del fichero a Si es símbolo de apertura, apilarlo en la pila b Si es de terminación y la pila está vacía, error c En otro caso, desapilar. Si el desapilado no es el de apertura correspondiente, hay error 3 Al finalizar el fichero, si la pila no está vacía, hay error Ejemplo: { [ ( ) ( ) ] ( ) { [ ( [ ( [ { ( { { [ { [ { { { {

7 7 ESQUELETO DE LA CLASE AnalizadorJava PARA EL PROGRAMA DE COMPROBACIÓN DE SIMBOLOS EQUILIBRADOS Los objetos a apilar contienen un token y un número de línea II Implementación de llamadas a procedimientos Cuando se llama a un nuevo método, deben salvarse las variables locales del llamador (para no sobreescribir) y también la posición actual dentro de la rutina llamante. Caso particular : métodos recursivos III Evaluación de expresiones precedencia de operadores Empleando un mecanismo directo de evaluación: Notación postfija Ejemplo: ^ 5 * 3 * 6 / 7 ^ 2 ^ 2 Para evitar confusión: (1 2) ( ( ( 4 ^ 5) * 3 ) * 6 ) / ( 7 ^ ( 2 ^ 2 ) ) ) Con notación postfija: ^ 3 * 6 * ^ ^ / Pila La pila es utilizada por la máquina postfija para la evaluación También se emplea pila para convertir una expresión infija en postfija: Cuando se encuentra un operando, se pasa directo a la salida. Cuando se encuentra un operador, debe esperar a encontrar su segundo operando Los operadores pendientes se pueden almacenar de forma apropiada en una pila Entrada y salida de la pila: Paréntesis izquierdo: se apila directamente Paréntesis derecho: Desapilar símbolos hasta encontrar ( Operador: Desapilar todos los símbolos hasta encontrar un símbolo de menor precedencia o un símbolo de igual precedencia con asociatividad derecha. Luego apilarlo. Fin de entrada: Desapilar el resto de símbolos

8 8 Convertir una expresión infija en postfija: E. Infija: 1 2 ^ 3 ^ 3 ( * 6 ) * 7 E. Postfija: ^ ^ * + 7 * ^^ 4 5 6* + 7 * ^ ^ ^ ^ ^ ^ ( ( + ( * + ( * + ( * * 1 2 ^ 3 ^ 3 ( * 6 ) * 7 Paréntesis izquierdo: se apila directamente Paréntesis derecho: Desapilar símbolos hasta encontrar ( Operador: Desapilar todos los símbolos hasta encontrar un símbolo de menor precedencia o un símbolo de igual precedencia con asociatividad derecha. Luego apilarlo Fin de entrada: Desapilar el resto de símbolos Además de la pila se requiere una Tabla de Precedencias para decidir las eliminaciones de la pila Este análisis necesita un tiempo lineal y un solo recorrido de la entrada, utilizando dos pilas

9 9 COLAS Estructura de datos en la cual se puede encontrar directamente y/o eliminar el elemento más antiguo y solo se puede insertar después del elemento más reciente Se puede identificar un frente y un final Operaciones naturales: insertar (al final) eliminar (al frente) primero (acceder elemento de frente) Ejemplos: trabajos que se mandan a impresión. Estructura FIFO: First In, First Out (primero en entrar, primero en salir) Interfaz: Una Cola se puede definir como class Queue import SNode; class Queue {SNode lastnode; SNode firstnode; Queue () { firstnode = lastnode = null; public void pushelement(object value) { if(firstnode == null) lastnode =firstnode = new SNode(value); else { lastnode = lastnode.next= new SNode(value)); Todas las operaciones básicas sobre las colas tardan un tiempo O (1) Colas Dobles Es una estructura similar a una cola, excepto que está permitido el acceso por ambos extremos La clase Cola Doble puede plantearse como subclase de Cola. Los métodos de Cola Doble son: Insertar al principio Insertar al final Eliminar al principio Eliminar al final Insertar al final y Eliminar al principio, son heredados Observar que la eliminación de nodos al final de una lista no está soportada de manera eficiente

10 10 IMPLEMENTACIONES DE PILAS Y COLAS Ambos tipos de estructuras pueden implementarse empleando un vector o una lista enlazada En ambos casos las operaciones se ejecutan en tiempo constante, son muy rápidas En otros lenguajes de programación, la implementación basada en vectores emplea más memoria pero menos tiempo que la implementación con listas enlazadas En Java no es relevante, debido al tratamiento de los objetos con referencias ( cada elemento de un vector es solo una referencia) OTROS TIPOS DE LISTAS ENLAZADAS Listas Circulares Listas enlazadas dobles Listas Circulares dobles Listas con cabecera ( para cada caso anterior) Listas enlazadas ordenadas LISTAS CIRCULARES Una desventaja de las listas lineales: dado un puntero p a un nodo de la lista, no se puede alcanzar cualquier otro nodo que preceda al nodo p Ventajas: Si se modifica la estructura : el next en el último nodo contiene un puntero al primer nodo, en lugar de ser nulo ( Lista Circular) Desde cualquier nodo de la lista es posible llegar a cualquier otro nodo de la lista No hay ningún nodo natural com primero o último. Convención: El puntero externo de la lista apunta al último nodo Pueden utilizarse para representar pilas o colas La pila puede considerarse como un puntero al último nodo de la lista circular, siendo que el primer nodo es la parte superior de la pila Al utilizar una lista circular, una cola puede especificarse mediante un solo puntero al nodo final de la cola y el siguiente nodo es el primero Pensar en la implementación de una cola con lista circular y escribir los métodos push y remove Algunas particularidades de listas circulares. Ejemplo: Si la lista tiene un solo nodo, este nodo tiene siguiente y por tanto debe reverse la operación EliminarSiguiente

11 11 LISTAS CON NODO CABECERA Una lista con nodo de cabecera es aquella en la que el primer nodo de la lista contendrá en su campo dato algún valor que lo diferencie de los demás En el caso de utilizar listas con nodo de cabecera, usaremos el apuntador CAB para hacer referencia a la cabeza de la lista. Un lista con nodo cabecera satisface el requerimiento: cada nodo que contiene un elemento tiene un nodo anterior. Esto simplifica las operaciones de eliminación e inserción, pues no hay que tratar los casos especiales para listas vacías. Se simplifica el código y aumenta la velocidad a cambio de un despreciable aumento de espacio ( Para algunos TRUCO SUCIO: celdas ficticias) En una lista circular, la ejecución del recorrido desde un nodo cualquiera requiere saber cuando se ha recorrido toda la lista. Esto puede lograrse con otro puntero externo estacionario ( al primer nodo de la lista) o bien trabajando con un nodo cabecera. LISTAS DOBLES ENLAZADAS En las listas enlazadas simples es fácil avanzar, pero la implementación de retroceder no puede ser eficiente con una sola referencia siguiente. En algunas aplicaciones esto es crítico ( Editores de texto) Se puede modificar la estructura de manera que cada nodo tenga una referencia al siguiente y al anterior (Lista doblemente enlazada), con o sin cabecera No obstante, éstas no soportan de forma eficiente algunas operaciones. LISTAS DOBLES ENLAZADAS CIRCULARES Se puede modificar para que principio y fin estén conectados entres sí ( Lista dob. enl. Circular) Así se tienen recorridos y búsquedas en forma sencilla en ambos sentidos Ya no se usa nil para decidir si un avance lleva al final de la lista Notar que eliminar un nodo aux de la lista puede codificarse como: aux. prev.next = aux. next; aux.next. prev = aux.prev LISTAS ENLAZADAS ORDENADAS Es una lista en la que los elementos se guardan en forma ordenada. La diferencia fundamental en esta estructura es la rutina de inserción También se modifica la búsqueda

12 12 Un modelo CONSIDERACIONES DE MODELADO Iteradores: patrón de diseño de software que encapsula métodos que permiten recorrer los elementos de una colección La diferencia fundamental en esta estructura es la rutina de inserción Una lista es un contenedor de objetos, la cual almacena cada elemento en una posición y mantiene esas posiciones dispuestas en orden lineal. Un contenedor es una estructura que almacena y organiza una colección de objetos, llamados los elementos del contenedor y proporciona acceso a los mismos a través de los métodos de un TAD. Pilas, Colas y Listas son ejemplos de contenedores La clase que implementa la interfaz Lista, si se desea un rápido acceso a la información, contendrá dos referencias, que apunten al primer y último nodo de la lista respectivamente. Para terminar de hacer simétrica la representación se podría añadir un nodo cabecera y un nodo final para evitar que la lista se quede vacía. ITERADORES Una operación típica a realizar con una lista de elementos es recorrerlos en orden, uno de cada vez, por ejemplo para buscar un elemento específico o para sumar los valores asociados. Un iterador es un patrón de diseño de software que abstrae el proceso de recorrer una colección de elementos. Un iterador consta de una secuencia S, una posición actual en S y una forma de avanzar a la siguiente posición convirtiéndola en su posición actual. Java proporciona una versión simplificada de un iterador en el paquete java.util, el cual define dos métodos: public interface Iterador public boolean hasnext(); public Object next() {se convierte en la posición actual

13 13 Al trabajar con una clase iteradora, la clase Lista no mantendría ninguna noción de posición actual y solamente contendría los métodos que tratan a la lista como una unidad, como esvacio() y anular(). public interface IteradorLista extends Iterador public void modificar(object o) throws... public void insertar(object o); public void suprimir() throws... A continuación se muestra un método que utiliza un iterador para visualizar los elementos de la lista l. Se puede observar que la iteración sobre las listas se realiza de una forma muy natural. public static void visualizar (ListaIter l) { System.out.print("Los elementos de la lista son: "); Iterador itr = l.iteradorlista(); while (itr.hasnext()) System.out.print((Integer) itr.next() + " "); Se declara itr como un iterador que puede acceder a la lista enlazada l. Esto requiere el uso de un constructor iteradorlista(). La primera vez que se llama a next(), se obtiene el primer elemento de l. Para implementar un iterador es necesario escribir su código y definir e implementar una clase. Esta clase no es visible al usuario. Es suficiente con que el usuario conozca la interfaz Iterador y la especificación del iterador, como se ha mostrado en el ejemplo anterior. public class ListaEnlazada implements ListaIter private Nodo cabecera; public ListaEnlazada()... public boolean esvacio(). public void anular() ; public IteradorLista iteradorlista() { return new IteradorListaEnlazada(this); Este método devuelve un objeto IteradorListaEnlazada, lo cual es correcto ya que es subtipo de IteradorLista que a su vez es subtipo de Iterador. A continuación se muestra la clase IteradorListaEnlazada. Se implementa como una clase privada y estática, anidada dentro de otra clase. Al estar declarada dentro de otra clase es posible acceder a los atributos y métodos privados de la clase ListaEnlazada. Esto es apropiado puesto que IteradorListaEnlazada es realmente parte de la implementación de la clase ListaEnlazada. private static class IteradorListaEnlazada implements IteradorLista private ListaEnlazada lalista; private Nodo actual; public IteradorListaEnlazada(ListaEnlazada l).. //métodos de la interfaz Iterador public boolean hasnext() public Object next() //métodos de la interfaz IteradorLista public void modificar(object o) public void insertar(object e)... public void suprimir()throws Lo que se ha mostrado es un ejemplo simplificado de iterador. Se podría haber utilizado un iterador más sofisticado que permitiera recorrer la secuencia en los dos sentidos, usando para ello los métodos hasprevious() y previous(). Además, puede ser necesario, en ocasiones, tener definidos varios iteradores. En ese caso se recomienda no usar el iterador mientras se modifica la secuencia. Jerarquía de herencia para los TAD secuencias Hemos presentado tres tipos de secuencias (vectores, listas y listas con iteradores) que han dado lugar a la definición de diferentes interfaces y clases. Estas definiciones pueden redefinirse agrupando los métodos y organizándolos en una jerarquía de herencia.

14 14 LISTAS ORTOGONALES En este tipo de lista se utiliza para representar matrices. Los nodos contienen cuatro apuntadores. Uno para apuntar al nodo izquierdo (li),otro para apuntar al derecho(ld), otro al nodo inferior(lb) y por último un apuntador al nodo superior(la). UNA APLICACIÓN DE LISTAS ENLAZADAS: MATRICES ESPARCIDAS Matriz rala o esparcida: matriz cuyo contenido está formado en su mayoría por ceros Alternativa empleando listas enlazadas: Una lista enlazada circular que represente una columna dummy, con tantos elementos como filas tenga la matriz. Cada elemento apunta al primer elemento de la fila respectiva Una lista para una fila dummy, con tantos elementos como columnas tenga la matriz. Cada elemento apunta al primer elemento de la columna respectiva Cada nodo de las listas dummy sirven como un nodo de encabezamiento para la lista de fila o de columna Los nodos de las listas que tienen los elementos de la matriz contienen: id fila, idcolumna, valor, next de fila, next de columna El primer nodo de la lista fila dummy coincide con el primer nodo de columna dummy y sirve como puntero de la nueva estructura Una estructura donde los nodos aparecen en más de una lista y contiene más de un puntero se denomina: LISTA MULTIENCADENADA Tener en cuenta que aquí los elementos no se acceden por referencia directa como en los arreglos. Los procedimientos son elborados.