6. Listas Generalizadas

Transcripción

1 6. Listas Generalizadas Una lista enlazada es una estructura de datos en la cual los objetos están organizados linealmente. Listas enlazadas proveen una forma simple de estructuar conjuntos dinámicos de datos. Una lista puede tener diferentes formas, puede ser enlazadas simple, doblemente enlazada, ordenada o circular. Una lista generalizada, A, es una secuencia finita de n 0 elementos, α 1,..., α n, donde α i es un elemento átomo o una lista. Si es una lista, se llama sublista de A. Si n 1, entonces α 1 se dice la cabeza de A y el resto la cola. Ejemplos: A = (a,(b,c)) B = (A,A,()) C = (a,c) Consecuencias: Listas generalizadas pueden ser compartidas o pueden ser recursivas. 31

2 structurelist(item) declare CREAT E() list ADD IT EM(list, item) list ADD LIST (list, list) list DELET E I T EM(list, item) list DELET E L IST (list, list) list HEAD IT EM(list) item HEAD LIST (list) list IS EMP T Y (list) boolean EQU AL(list, list) boolean for all l, l 1, l 2, l 3 LIST, i, i 1 IT EM let IS EMP T Y (CREAT E()) ::= true IS EMP T Y (ADD IT EM(l, i)) ::= false IS EMP T Y (ADD LIST (l, l 1 )) ::= false EQUAL(CREAT E(), l) ::= IS EMP T Y (l) EQUAL(l, CREAT E()) ::= IS EMP T Y (l) EQUAL(ADD IT EM(l, i), ADD IT EM(l 1, i 1 ) ::= if i = i 1 then EQUAL(l, l 1 ) else false EQUAL(ADD IT EM(l, i), ADD LIST (l 1, l 2 ) ::= false EQUAL(ADD LIST (l, l 1 ), ADD IT EM(l 2, i)) ::= false EQUAL(ADD LIST (l, l 1 ), ADD LIST (l 2, l 3 )) ::= EQUAL(l, l 2 ) EQUAL(l 1, l 3 ) HEAD IT EM(CREAT E()) ::= error HEAD IT EM(ADD IT EM(l, i)) ::= if IS EMP T Y (l) then i else HEAD IT EM(l) HEAD IT EM(ADD LIST (l, l 1 )) ::= if IS EMP T Y (l) then error else HEAD IT EM(l) HEAD LIST (CREAT E()) ::= error HEAD LIST (ADD IT EM(l, i)) ::= if IS EMP T Y (l) then error else HEAD LIST (l) HEAD LIST (ADD LIST (l, l 1 )) ::= if IS EMP T Y (l) then l 1 else HEAD LIST (l) DELET E IT EM(CREAT E(), i) ::= CREAT E() DELET E IT EM(ADD IT EM(l, i), i 1 ) ::= if i = i 1 then DELET E IT EM(l, i 1 ) else ADD IT EM(DELET E(l, i 1 ), i) DELET E IT EM(ADD LIST (l, l 1 ), i) ::= ADD LIST (DELET E IT EM(l, i), DELET E IT EM(l 1, i)) DELET E LIST (CREAT E(), l) ::= CREAT E() DELET E LIST (ADD IT EM(l, i), l 1 ) ::= ADD IT EM(DELET E LIST (l, l 1 ), i) DELET E LIST (ADD LIST (l, l 1 ), l 2 ) ::= if EQUAL(l 1, l 2 ) then DELET E LIST (l, l 2 ) else ADD LIST (DELET E LIST (l, l 2 ), DELET E LIST (l 1, l 2 )) Supongamos una representación por punteros de modo que se tiene un nodo con tres campos: tag (0: atomo, 1: sublista) data (Si tag = 0, data es un dato que se almacena, and si tag = 1, data es un puntero a la sublista). puntero al siguiente elemento de la lista. Con esta representación, las lista dadas como ejemplo quedan representadas como: 32

3 A 0 a 1 0 (a,(b,c)) 0 b 0 c 0 (b,c) B (A,A,()) C 0 a 1 0 (a,c) Figura 8: Ejemplo de listas generalizadas Un ejemplo de aplicación de lista generalizadas en la representación de un polinomio. Ejemplo: P (x, y, z) = x 10 y 3 z 2 + 2x 8 y 3 z 2 + 3x 8 y 2 z 2 + x 4 y 4 z + 6x 3 y 4 z + 2yz z 2 (x 10 y 3 + 2x 8 y 3 + 3x 8 y 2 ) + z(x 4 y 4 + 6x 3 y 4 + 2y) z 2 (y 3 (x x 8 ) + y 2 (3x 8 )) + z(y 4 (x 4 + 6x 3 ) + y(2x 0 )) 33

4 z y x x Figura 9: Ejemplo de un polinomio como lista Cuál es la representación de los nodos de esta lista? El hecho que listas puedan ser compartidas puede resultar en un mejor manejo de espacio. Para hacer esto, exteremos la definición de una lista para permitir el manejo de nombres de sublistas. Por ejemplo, en la lista A=(a,(b,c)), la sublista (b,c) puede ser llamada Z de manera que A = (a,z(b,c)), o en forma más consistente A(a,Z(b,c)). Listas que son compartidas por otras, tal como A en los ejemplos, crea problemas cuando uno desea agar o borrar un nodo que está al frente. Si el primer nodo de A es borrado, es necesario mover los punteros de la lista B al segundo elemento de A. El problema también aparece cuando se aga un nodo al comienzo. Aún más, no siempre se conocen todas las listas que comparten una definición. Una solución fácil es agar un nodo cabecera. El tag de la cabecera no importa y es inicializado con 2. Adicionalmente al uso de la cabecera para indicar el comienzo de una lista, esta cabecera puede contener un contador indicando el número de listas que hacen referencia a ella. Así cuando uno desea eliminar una lista, esta lista sólo puede ser eliminada si es que no hay listas que hagan referencia a ella. A continuación se presenta el dibujo de la representación con cabecera de las lista de ejemplo: 34

5 2 3 0 a 1 0 A(a,Z(b,c)) b 0 c 0 Z(b,c) B(A,A,()) a 1 0 C(a,C) Figura 10: Ejemplo de lista generalizadas con encabezamiento El uso del contador resuelve el problema de listas compartidas, pero cuando existen listas con ciclos, el contador nunca llega a cero. Por ejemplo: Figura 11: Listas con ciclos Desafortunadamente, cuando se usan listas recursivas (con ciclos) es posible que se acabe el espacio disponible aunque no todos los nodos estén sio usados, ya que no se pueden devolver los nodos a medida que se van borrando. Cuando esto ocurre, es posible recolectar el espacio sin uso mediante un proceso conocido como colección de basura o garbage collection. 35

6 6.1. Aplicación de Listas: Recolección de Basura y Compactación En un ambiente de computadores multi-procesos, muchos programas residen en memoria al mismo tiempo. Diferentes programas tiene diferentes requerimientos de memoria. Así un programa puede requerrir 60K o 300K de memoria. En cualquier momento que el sistema necesite memoria, necesita localizar memoria continua del tamaño deseado. Cuando la ejecución de un programa es terminada, la memoria que ha sido ocupada debe ser liberada y disponible para otro programa. Más aún, bloques de memoria pueden ser liberados en una secuencia diferente a la que fueron solicitados. Suponga por ejemplo el siguiente caso: Se tiene una memoria de palabras y 5 programasa P1, P2, P3, P4, y P5 que requieren bloques de memoria de tamaños 10000, 15000, 6000, 8000 y La vista de la memoria al localizar el programa P5 sería: P1 P2 P3 P4 P5 Free Space Figura 12: Memoria con 5 procesos en ejecución Asuma ahora que el programa P4 y P2 completaron su ejecución y que por lo tanto la memoria es liberada: P1 Free P3 Free P5 Free Space Figura 13: Memoria con 2 procesos terminados Ahora se tienen 3 bloques de memoria contigua libres y tres ocupados. Con el propósito de seguir permitio la localización de memoria, es necesario mantener istro de los bloques que no están en uso. Para eso se usa un lista de bloques de memoria que no están en uso. El proceso de recolección de basura es llevado a cabo en dos pasos: (1) marcación de los bloques que están en uso y (2) compactación de los bloques libres a memoria disponible. Este segundo paso es trivial si los bloques son de igual tamaño llegando a ser de O(n), sio n el número de nodos. Cuando existe un tamaño variable por nodo, es deseable compactar la memoria de manera que todos los nodos libres queden en memoria contigua, lo que se llama compactación de memoria. La compactación de memoria reduce el tiempo de recuperación. 36

7 6.2. Representation de listas Considere el caso simple de listas con elementos de un sólo tipo: longitud Figura 14: Lista doblemente encadenada La representación de esta lista es: Tipos nodo lista = lista = valor : elemento sig, ant : puntero a nodo lista f longitud : nat izquierda, derecha : puntero a nodo lista f Algunas algoritmos son los siguientes. En todos los casos la complejidad es de orden lineal O(n) con n sio el numero de elementos en la lista. Procedure concatenar( lista x; lista y; var lista z) z lista vacia() p x.izquierda agar der(z, p valor) p y.izquierda agar der(z, p valor) 37

8 Procedure inversa( lista l) p l derecha r nil q p sig p sig r p ant q r p p q l r Func buscar( lista l, elem e) p l derecha while p nil and p valor e do if p nil then return false else return true Ahora considere listas doblemente encadenadas y, además, circulares: Figura 15: Lista doblemente encadenada y circular La representación de esta lista es por punteros es: Tipos nodo lista = lista = valor : elemento sig, ant : puntero a nodo lista f longitud : nat sentinela : puntero a nodo lista f En esta representación un nodo es usado como cabecera o sentinela de la lista de nodos. Los algoritmos soy muy parecidos a los anteriores, tenio en cuando que los punteros siguientes y anteriores nunca son nulos. La condición de parada es que el puntero sea igual a la cabecera o 38

9 sentinela. Otra representación de lista es usando arlos. Se pueden usar 3 arlos para lista doblemente encadenadas, un arlo de punteros anteriores, un arlo de puntero al siguiente y un arlo de valores, tal como la figura que se muestra: sig valor ant Figura 16: Lista doblemente encadenada y circular con representación por arlos Considerando la memoria como un arlo de una dimensión, otra representación en un sólo arlo es: N Figura 17: Lista doblemente encadenada y circular con representación por arlos En esta representación se maneja un desplazamiento de 0, 1 y 2, para el valor, el próximo y el anterior, respectivamente. Asumio esta represnetación, algunas puntas interesantes son:?qué estructuras o variables son necesarias para manejar la lista y usar asignación dinámica de memoria? Basada en esta representación,?qué debería hacerse para manejar la lista en forma compactada, osea, usando los primeros elementos del arlo? 39

10 Para el caso de listas generales: Tipos nodo lista gen = tipo : bool valor : elemento lista : lista gen sig : puntero a nodo lista f lista gen = ref erencias : natural primero : puntero a nodo lista gen f Procedure concatenar(lista gen x; lista gen y; var lista gen z) v copia lista gen(x) w copia lista gen(y) if v = nil then z w else [avanzamos hasta el último elemtno de v] p v primero while p sig nil do [y lo unimos con w] p sig w z v Procedure inversa gen(lista gen l) p l primero r nil q p if (q tipo) then inversa gen(q lista) q sig r r q l r 40

11 Func buscar gen( lista gen l, elem e) p l primero if p tipo = L then if buscar gen(p lista, e) then return true else else if p valor = e then return true else return false Dos algoritmos de profundidad son: Func depth 1 ( node list l) p l h 1 0 h 2 0 if p = nil then return h 1 h depth 1 (p sig) if p tipo = L then h depth 1 (p lista primero) return max(h 1, h 2 ) Func depth 2 ( lista gen l) p l primero n 0 long 0 if p tipo = L then n max(n, depth 2 (p lista)) long long + 1 return max(n, long) 41