Tema 3: Listas Enlazadas

Transcripción

1 Apuntes elaborados por: Eduardo Quevedo/ Raquel López García Revisado por: Javier Miranda el???? Tema 3: Listas Enlazadas En este tema se va a trabajar con memoria de tipo dinámico, organizada por nodos y por punteros. Igual que hicimos en el tema del array, comenzaremos considerando que el contenido de la lista no es necesario mantenerlo ordenado (Lista no ordenada).antes de comenzar con algunos procedimientos que podemos realizar con listas, veremos las declaraciones necerias para la interfaz y el cuerpo de nuestra lista Interfaz de la lista enlazada package Lista_Dinamica is Llena : exception; No_Encontrado : exception; type T_Lista is limited private; procedure Insertar ( Lista : in out T_Lista, Valor : in Integer); -- Excepciones : Llena -- Resto de procedimientos y funciones.... private... end Lista_Dinamica; Como puede verse, ahora ya no se especifica ningún tamaño, pues la lista puede llegar a ocupar toda la memoria RAM del ordenador. La especificación limited private se utiliza para impedir que una variable de tipo T_Lista se pueda copiar en otra variable de tipo T_Lista. Es decir, sirve para que cada variable de tipo T_Lista se corresponda con un único contenido. Si no se prohibe la copia el programador puede hacer disparates como el siguiente: Lista_1 :T_Lista; Lista_2 :T_Lista; Begin Lista_2 = Lista_1 1

2 Veamos ahora en detalle cómo se declaran los nodos en la parte privada de la interfaz: private type T_Nodo; -- La declaracion de este tipo se utiliza para romper la referencia mutua que se -- genera despues entre T_Nodo y T_Nodo_Ptr, indica que en el programa va - -- a aparecer un T_Nodo type T_Nodo_Ptr is access T_Nodo; type T_Nodo is record Valor : Integer; Siguiente : T_Nodo_Ptr := null; end record; -- El null dice que ese puntero esta inicializado para no apuntar a nada type T_Lista is record Primero : T_Nodo.Ptr := null; end record; Cuerpo de la lista enlazada with Unchecked_Deallocation; package body Lista_Dinamica is procedure Free is new Unchecked_Deallocation (T_Nodo, T_Nodo_Ptr); -- Cuerpo de todos los subprogramas end Lista; El procedimiento Free es un genérico, en el cual no se observan los parámetros y en donde T_Nodo y T_Nodo_Ptr se utilizan para construir el genérico. La finalidad del procedimento Free (como su propio nombre indica) es liberar un nodo. Inserción en lista enlazada Si la lista no está ordenada la forma más rápida de insertar un elemento es insertarlo siempre por el principio de la lista. Para realizar la inserción hay que crear un nuevo nodo y arreglar 2 punteros (el puntero a este nuevo primer elemento, y en este nuevo nodo hay que guardar copia de la dirección del nodo que estaba antes como primer nodo, y que ahora pasa a ser el segundo). Si los datos deben estar ordenados (Lista Ordenada) entonces la rutina de inserción 2

3 deberá buscar (mediante un bucle) la posición de la inserción.pasaremos a ver algunas formas de implementar este procedimiento, empezaremos con un programa mas largo q iremos optimizando: procedure Insertar (Lista : in out T_Lista Valor : in Integer) is Nuevo : T_Nodo_Ptr; Nuevo : new T_Nodo; -- Se crea un nuevo nodo Nuevo.Valor := Valor; -- Se llena el nodo que se acaba de crear Nuevo.Siguiente := Lista.Primero; -- El primero de la lista se copia en el siguiente del nuevo -- Con ello se apunta a donde apunta nuevo Lista.Primero := Nuevo exception when Storage_Error => -- Nos avisa de quen estamos llenando la memoria del ordenador, con -- la finalidad de que borremos algo raise Llena; end Insertar; Se llega a una simplificación del procedimiento de Insertar si los valores de Nuevo se inicializan al declarar la variable: procedure Insertar (Lista : in out T_Lista Valor : in Integer) is Nuevo : T_Nodo_Ptr := new T_Nodo (Valor => Valor, Siguiente => Lista.Primero); Lista.Primero := Nuevo exception when Storage_Error => raise Llena; end Insertar; Ahora veremos un procedimiento que insertará los elementos de uan lista de forma ordenada para ello supondremos que Clave es un string y que Long_Clave es la longitud de dicho string: procedure Insertar_Ordenadamente (Lista : in out T_Lista; Objeto : in T_Informacion) is -- Creación de un nuevo nodo Nuevo : T_Nodo_Ptr := new T_Nodo'(Libro => Libro, Siguiente => null); -- Creación de las variabes puntero, seguro, estas serán punteros que nos -- ayudaran a realizar un avance seguro al recorrer la lista Puntero : T_Nodo_Ptr := Lista.Primero; 3

4 Seguro : T_Nodo_Ptr := null; -- Caso de lista vacía if Lista.Primero = null then Lista.Primero := Nuevo; -- Caso de lista no vacía -- Avance seguro teniendo en cuenta que el siguiente sea /= null while Puntero.Siguiente /= null and Puntero.Objeto.Clave (1.. Puntero.Objeto.Long_Clave) < Objeto.Clave (1.. Objeto.Long_Clave) loop Seguro := Puntero; Puntero := Puntero.Siguiente; -- Observamos 3 casos: Va en el primer lugar, va al final, o va en medio -- 1) Está al principio if Puntero = Lista.Primero then Nuevo.Siguiente := Lista.Primero; Lista.Primero := Nuevo; -- 2) Está al final de la lista elsif Puntero = null then Puntero.Siguiente := Nuevo; 3) Está en el medio Nuevo.Siguiente := Puntero; Seguro.Siguiente := Nuevo; end Insertar_Ordenadamente; Búsqueda en lista enlazada Para buscar un elemento en una lista no ordenada hay que recorrer los nodos. Es importante recordar que los nodos están repartidos por toda la memoria del ordenador (a nosotros nos da igual donde estén), y hay que hay que tener en cuenta que los nodos no estan en posiciones de memoria consecutivas por lo que los atributos de Ada Pred y Succ no pueden ser utilizados en memoria dinámica. Como siempre, la función que realiza la búsqueda retornará un True en caso de que encuentre el elemento buscado. Borrado en lista enlazada Para borrar un nodo hay primero que buscarlo (mediante un bucle), pero hay que tener en cuenta que al borrarlo el puntero del nodo anterior hay que modificarlo para que apunte al que esté después del nodo que borramos. Para recordar la posición del nodo anterior sin tener que recorrer de nuevo todos los elementos de la lista se utiliza la técnica de avance seguro. En general cada 4

5 vez que se borra hay que arreglar dos punteros, excepto cuando borramos el primero o el último elemento, donde sólo hay que arreglar un puntero. procedure Borrar (Lista : in out T_Lista; Clave : in String; Long_Clave : in Natural) is -- Creación de dos punteros: el segundo es para el avance seguro Puntero : T_Nodo_Ptr := Lista.Primero; Seguro : T_Nodo_Ptr := null; -- Caso de lista vacía if Lista.Primero = null then raise No_Encontrado; -- Caso de lista no vacía -- Avance seguro teniendo en cuenta que el puntero sea /= null while Puntero /= null and then Puntero.Objeto.Clave (1.. Puntero.Objeto.Long_Clave) /= Clave (1.. Long_Clave) loop Seguro := Puntero; Puntero := Puntero.Siguiente; -- 3 casos: Está en el primer lugar, está al final, o está en medio -- 1) Está al principio if Puntero = Lista.Primero then Lista.Primero := Puntero.Siguiente; Free (Puntero); -- 2) Está al final elsif Puntero = null then raise No_Encontrado; -- 3) Está en medio Seguro.Siguiente := Puntero.Siguiente; Free (Puntero); end Borrar; Algunos ejercicios más de listas simplemente enlazadas: Ahora se veran algunos otros procedimientos útiles para trabajar con listas, al igual que en temas anteriores se empezará con una version algo mas larga para ir optimizandola poco a poco lo q ayudará a la comprensión de los algoritmos. 5

6 Función que calcule el número de elementos de una lista: La idea de este algoritmo es bastante sencilla, lo que tendremos q hacer para ver la longitud de una lista es simplemente recorrer la lista hasta el final e ir contando el número de saltos. El principal motivo por el que deberíamos implementar es que nos permite aprender y comprender el manejo de los nodos. Versión 1.0: function Longitud (Lista : in T_Lista) return Natural is Contador : Natural := 0; -- Inicializamos actual a null Actual : T_Nodo_Ptr := null; -- Comprobamos que la lista no está vacia if Lista.Primero = null then -- Retornamos cero ya que no hay elementos en la lista return 0; -- Avanzaremos en la lista utilizando el puntero actual Actual := Lista.Primero; -- Iremos recorriendo la lista hasta que nos encontremos while Actual /= null loop -- Aumentaremos el contador que nos proporcianará la longitud Contador := Contador + 1; Actual := Actual.Siguiente; -- retornamos la variable contador que será la longitud de la lista return Contador; end Longitud; Versión final: Vemos en la versión anterior que estamos comprobando dos veces si la lista está vacía, así que esta será la optimización que realicemos en esta versión final de nuestro algoritmo. function Longitud (Lista : in T_Lista) return Natural is Contador : Natural := 0; -- Inicializaremos ahora Actual a Lista.Primero para evitar comprobar dos -- veces que la lista esté vacía. Actual : T_Nodo_Ptr := Lista.Primero; while Actual /= null loop Contador := Contador + 1; 6

7 Actual := Actual.Siguiente; return Contador; end Longitud; Procedimiento de Copiar: Debido a que mediante el limited private se ha limitado la copia directa en listas sería bueno tener un procedimiento que realizase dicha copia, como normalmente cuando asignamos variables el destino lo ponemos a la izquierda y el origen a la derecha aquí también se tendrá en cuenta dicho orden, es decir el primer parámetro del procedimiento será el destino y el segundo el origen: procedure Copiar (Destino : in out T_Lista Origen : in T_Lista Is -- Irá recorriendo la lista Origen Actual : T_Nodo_Ptr := Origen.Primero; -- Irá recorriendo la lista Destino Nuevo : T_Nodo_Ptr := new T_Nodo'(Valor => Actual.Valor, Siguiente => null); -- Se mira si se dan las condiciones propicias para que se haga la copia. -- Primero comprobaremos que la lista Destino esté vacía. if Destino.Primero /= null then raise Parametro_Erroneo; -- Seguidamente comprobaremos que la Origen contenga algo elsif Origen.Primero = null then -- Saldríamos del procedimiento return; -- Comenzamos el duplicado de la lista Actual := Origen.Primero; Destino.Primero := Nuevo; -- Debemos tener cuidado con esta condición ya que so pusiéramos -- Actual.Siguente /= null no copiaríamos el ultimo elemento de la lista while Actual /= null loop -- Avanzamos en la lista Origen Actual := Actual.Siguiente; Nuevo.Siguiente :0= new T_Nodo; -- Avanzamos en la lista Destino Nuevo := Nuevo.Siguiente; -- Copiamos la lista Nuevo.Valor := Actual.Valor; end Copiar; 7

8 Procedimiento de intercambiar consecutivamente: El procedimiento de intercambiar consecutivamente serviría para intercambiar en el procedimiento de ordenación por burbuja, pues intercambia nodos consecutivos, para selección o inserción habría que hacer un procedimiento que intercambiase dos nodos cualesquiera. Con este procedimiento aprenderemos la importancia del orden de las asignaciones para no perder ningún nodo en el camino: procedure Intercambiar_Consecutivo (Lista : in out T_Lista; Puntero_1 : in T_Nodo_Ptr; Puntero_2 : in T_Nodo_Ptr) is Anterior : T_Nodo_Ptr := Lista.Primero; -- Se hacen las comprobaciones previas -- Ninguno de los punteros puede estar apuntando a null if Puntero_1 = null or Puntero_2 = null then raise Parametro_Nulo; -- Los nodos deben ser consecutivos elsif Puntero_1.Siguiente /= Puntero_2 then raise Parametro_Erroneo; -- Si el Puntero_1 es el primero elemento de la lista es un caso sencillo. -- realizamos las asiganciones elsif Lista.Primero = Puntero_1 then Lista.Primero := Puntero_2; Puntero_1.Siguiente := Puntero_2.Siguiente; Puntero_2.Siguiente := Puntero_1; -- Si no, nos encontramos ante un caso general -- Debemos comprobar que el puntero este en la lista while Anterior /= null and then Anterior.Siguiente /= Puntero_1 loop Anterior := Anterior.Siguiente; -- Debemos evitar salirnos de la lista if Anterior = null then raise No_Encontrado; -- Realizamos las asiganciones Anterior.Siguiente := Puntero_2; Puntero_1.Siguiente := Puntero_2.Siguiente; Puntero_2.Siguiente := Puntero_1; end Intercambiar_Consecutivo; Se observa que las líneas: Puntero_1.Siguiente := Puntero_2.Siguiente; Puntero_2.Siguiente := Puntero_1; Se pueden sacar factor común. 8

9 Lista doblemente enlazada: La lista doblemente enlazada tiene la capacidad de recorrer la lista tanto hacia delante como hacia atrás, por ello es una lista mucho más flexible, en la interfaz bastará con definir un nodo anterior inicializado como siempre a null; (no apunta a nada) y en el record de T_Lista aparte del primero, es recomendable tener un puntero al último nodo (para poder recorrerla hacia atrás y para insertar rápidamente un nodo al final de la lista). La parte privada de la interfaz de la lista doblemente enlazada es: private type T_Nodo; type T_Nodo_Ptr is access T_Nodo; type T_Nodo is record Valor : Integer; Siguiente : T_Nodo_Ptr := null; Anterior : T_Nodo_Ptr := null; end record; type T_Lista is record Primero : T_Nodo_Ptr := null; Ultimo : T_Nodo_Ptr := null; end record; end Lista_Dinamica; Algunos ejercicios de listas doblemente enlazadas: Procedimiento de Insertar en lista no ordenada procedure Insertar (Lista : in out T_Lista Valor : in Integer) is Nuevo : T_Nodo_Ptr := new T_Nodo (Valor if Lista.Primero = null then Lista.Primero := Nuevo; Lista.Ultimo := Nuevo; Nuevo.Siguiente Lista.Primero.Anterior := Nuevo; Lista.Primero := Nuevo; exception when Storage_Error => raise Llena; end Insertar; := Lista.Primero; => Valor, Siguiente => null, Anterior => null); 9

10 Procedimiento de intercambiar consecutivamente: Es el análogo para listas doblemente enlazadas del ya hecho para las simplemente enlazadas, teniendo que arreglar dos punteros. Los comentarios serás los mismos que para el de listas simplemente enlazadas: procedure Intercambiar_Consecutivo (Lista : in out T_Lista; Puntero_1 : in T_Nodo_Ptr; Puntero_2 : in T_Nodo_Ptr) is Anterior : T_Nodo_Ptr := Lista.Primero; -- Se hacen las comprobaciones previas if Puntero_1 = null or Puntero_2 = null then raise Parametro_Nulo; elsif Puntero_1.Siguiente /= Puntero_2 then raise Parametro_Erroneo; -- Se intercambia if Puntero_1.Anterior /= null then Puntero_1.Anterior.Siguiente := Puntero_2; Lista.Primero := Puntero_2; if Puntero_2.Siguiente /= null then Puntero_2.Siguiente.Anterior := Puntero_1; Lista.Ultimo := Puntero_1; P2.Anterior := P1.Anterior; P1.Siguiente := P2.Siguiente; P1.Anterior := P2; P2.Siguiente := P1; end Intercambiar_Consecutivo; 10