Normalmente el primer objeto del arreglo tiene el índice 0, aunque esto varía de lenguaje en lenguaje.

Transcripción

1 3. LISTAS 3.1 Arreglos Arreglos unidimensionales Un arreglo se usa para agrupar, almacenar y organizar datos de un mismo tipo. En un arreglo cada valor se almacena en una posición numerada específica dentro del arreglo. El número correspondiente a cada posición se conoce como índice. La estructura de un arreglo es: Normalmente el primer objeto del arreglo tiene el índice 0, aunque esto varía de lenguaje en lenguaje. Declaración: La declaración de un arreglo en pseudocódigo que se utilizará es: tipo [ ] nombrearreglo Un arreglo es un objeto por lo que para crear el espacio se utiliza el operador nuevo: nombrearreglo nuevo tipo [max] donde tipo puede ser un tipo de datos primitivo o un objeto, nombre es el nombre del arreglo y max es el número de localidades del arreglo. Es una buena costumbre que max sea declarado como una constante. Pág. 1

2 También puede declararse de la siguiente forma: tipo [] nombrearreglo nuevo tipo [max] Operaciones: almacenamiento, una operación de almacenamiento inserta un valor en el arreglo en una localidad específica. nomarreglo [i] valor recuperación, una operación de recuperación regresa el valor almacenado en una localidad específica del arreglo valor nomarreglo[i] donde i es la posición o índice del arreglo, que puede ser un entero o bien una expresión que al ser evaluada regresa un entero Por ejemplo: const int MAX 10 int [] arregloenteros nuevo int [MAX] arregloenteros [0] 1 arregloenteros [1] 10 a 5 arregloenteros [a-2] arreglosenteros [0] + arregloenteros [1] Esquemáticamente arregloenteros se vería como: número de localidades, como dato miembro público y constante de un arreglo se puede accesar el número de localidades: int identificador nomarreglo.longitud Ejemplos: a) Arreglos que utilizan datos primitivos 1. Leer una lista de números, almacenarlos en un arreglo e imprimirlos en orden inverso Pág. 2

3 clase NumerosReves principal const int MAX 10 //Número máximo de posiciones del arreglo //creación del arreglo de reales real [] numeros nuevo real [MAX] //se piden al usuario los datos escribe El tamaño del arreglo es: + numeros.longitud para indice 0 hasta numeros.longitud 1 escribe Dame el número que se encuentra en + índice lee numeros [indice] //se escribe al revés el arreglo escribe Los números al revés son: para indice numeros.longitud-1 hasta 0, -1 escribe numeros [indice] 2. Considere los siguientes datos miembro y la función constructora por default: clase EjemplosArreglo const int MAXLOC 100 int [] info EjemplosArreglo () info nuevo int [MAXLOC] para i 0 hasta info.longitud-1 escribe Dame el valor del arreglo en la posición + i lee info [i] A continuación se presentan algunas funciones miembro que podrían pertenecer a la clase EjemplosArreglo a) Calcular la suma de los elementos de un arreglo int sumaelem () suma 0 para i 0 hasta info.longitud-1 suma suma + info[i] regresa suma b) Calcular el promedio de los elementos de un arreglo Pág. 3

4 real promedio () regresa (sumaelem() / info.longitud) c) Der el elemento más grande del arreglo int maximo () max info [0] //El mayor es el 1ro. hasta que se demuestre lo contrario para i 1 hasta info.longitud-1 si max < info[i] entonces max info [i] regresa max d) Ordenar un arreglo por selección El algoritmo de selección ordena un arreglo de valores poniendo un valor particular en su posición final, i.e., el algoritmo selecciona el valor que debería ir en una posición y lo pone ahí. Considere un orden ascendente y el siguiente arreglo de números. Se busca el elemento menor del arreglo y se pone en la 1ra. posición, y entonces el arreglo queda como: Note que ahora la celda amarilla contiene al elemento más pequeño y que está en la posición que quedara cuando el arreglo esté completamente ordenado. A continuación se busca el siguiente más pequeño que deberá de estar en la segunda posición del arreglo: Pág. 4

5 y se intercambia con el elemento que ocupa la 2da. posición del arreglo. Y posteriormente se busca el siguiente más pequeño: Ahora el 5 deberá de ocupar la tercera posición del arreglo. Y se buscará el elemento más pequeño de los restantes: Por último se coloca el 6 en su posición correspondiente, intercambiándolo con el 8. Y así el arreglo queda ordenado: Nótese que el último elemento quedará automáticamente ordenado. A continuación se presenta el algoritmo: void ordenseleccion () int min, temp para indice 0 hasta info.longitud 2 min indice para busca indice+1 hasta info.longitud-1 si info[busca] < info [min] entonces min busca //se intercambian temp info [min] info [min] info [indice] info [indice] temp b) Arreglos que utilizan objetos La creación de un arreglo y la creación de objetos son dos cosas separadas. El mecanismo para trabajarlos es el mismo. Considere la siguiente clase en Java para crear CD: Pág. 5

6 /** * Define un disco compacto * */ class CD // datos miembro String titulo; String autor; int año; double precio; /** * Constructor para objetos de la clase CD */ CD(String t, String au, int a, double p) Titulo = t; autor = au; año = a; precio = p; /** * Escribe los datos miembro */ void escribe () System.out.println ("Título: " + titulo); System.out.println ("autor: " + autor); System.out.println ("año: " + año + " $ " + precio); System.out.println ("~~~~~~~~~~~~~~~~~~~~~~~~~~~~"); Y la clase discoteca donde se utiliza un arreglo de CD /** * Maneja un arreglo de CD */ class discoteca CD [] arreglocd; int numcd; final int MAXIMO = 100; /** * Constructora de la discoteca */ public discoteca() numcd = 0; arreglocd = new CD [MAXIMO]; /** * Inserta un CD Pág. 6

7 */ void insertacd (String tit, String au, int a, double costo) // se crea un CD if (numcd > MAXIMO) System.out.println ("Ya no hay lugar"); else CD nuevocd = new CD (tit,au,a,costo); arreglocd[numcd] = nuevocd; numcd++; /** * Escribe en pantalla todos los CD */ void escribe () for (int i = 0; i < numcd; i++) arreglocd[i].escribe (); /** * Calcula el costo total de la inversión */ double costo () double c = 0; for (int i = 0; i < numcd; i++) c = c + arreglocd[i].precio; return c; public static void main (String [] a) //Se crea una discoteca privada discoteca privada = new discoteca (); privada.insertacd ( "Storm Front", "Billy Joel", 1960, ); privada.insertacd ("Come On Over", "Shania Twain", 1990, ); privada.insertacd ("Graceland", "Paul Simon", 1991, ); System.out.println ("\ndiscoteca privada"); privada.escribe (); //Se crea una discoteca clasica discoteca clasica = new discoteca (); clasica.insertacd ("Concierto No. 5 para piano", "Tchaikowsky", 1763, 57.90); clasica.insertacd ("Carmen", "Bizet", 1896, 67.25); System.out.println ("\ndiscoteca clásica"); clasica.escribe (); //Reporta inversiones System.out.println ("El costo de lo invertido en la discoteca privada es $"+ privada.costo ()); System.out.println ("El costo de lo invertido en la discoteca clasica es $"+ clasica.costo ()); Pág. 7

8 La salida producida es: Pág. 8

9 3.1.2 Arreglos de dos dimensiones Listas Lineales Los arreglos examinados hasta el momento han sido unidimensionales en el sentido de que representan una lista simple de valores. Un arreglo bidimensional, como su nombre lo indica, tiene valores en dos dimensiones, en algunas ocasiones se le llama también tabla y se tiene acceso a sus elementos a través de la columna y el renglón del arreglo. Para definir un arreglo en dos dimensiones es necesario poner el tipo de la información que se desea almacenar (un tipo primitivo o un objeto) y especificar que se tendrán dos dimensiones: tipo [] [] nombre Ejemplos: a) Definir un arreglo bidimensional de enteros: int [] [] matriz b) Definir una tabla de booleanos: bool [][] tablero c) Definir un arreglo bidimensional de fichas ficha [] [] juego Como en los arreglos de una sola dimensión, el tamaño de las dimensiones se especifica cuando el arreglo es creado y el tamaño de cada dimensión puede ser diferente. Pág. 9

10 Así, para el ejemplo anterior: a) matriz nuevo int [5][5] b) tablero nuevo bool [10][MAX], donde MAX almacena un valor entero c) juego nuevo ficha [NUMCELDAS] [NUMCELDAS-2], donde NUMCELDAS almacena un valor entero Las operaciones que pueden realizarse con cada elemento de un arreglo son: almacenamiento recuperación En cada operación es necesario especificar unívocamente el elemento por lo que es necesario dar el índice para cada dimensión: Por ejemplo: Ejemplo Almacenamiento Recuperación a) matriz [2][3] 3 int x matriz [4][4] b) tablero [3][1] verdadero si tablero [2][2] entonces e1 c) juego [1][8] nuevo ficha () ficha f juego [0][0] Ejemplos: 1. Escribir una función estática que lea los elementos de una matriz de tamaño MAX. estatica int [][] leematriz () matriz nuevo int [MAX][MAX] para i 0 hasta MAX-1 para j 0 hasta MAX-1 escribe Dame el elemento + i +, + j lee matriz[i][j] regresa matriz 2. Suma de dos matrices Las operaciones de suma y resta de matrices están definidas para dos matrices si tienen el mismo número de: a) renglones b) columnas Pág. 10

11 La suma de dos matrices es la matriz obtenida de sumar pares correspondientes de elemento, de tal forma que si: a 11 a A = a n1 a 12 a 22 a n a 1n a 2n a nn y b 11 b B = b n1 b 21 b 22 b n b 1n b 2n b nn entonces a + b a + b A + B = a + b n1 n1 a + b a + b a n2 + b n2... a + 1n... a + 2n... a nn + b 1n b 2n b nn La diferencia A-B, es la matriz obtenida de restar los elementos de B de los elementos correspondientes de A: a11 b a21 b A B =... an1 b n1 a b n2 12 a b 22 a b n a b 1n 2n nn 1n a b 2n a b nn Una función para sumar matrices podría ser: estática int [] [] suma (int [][] A, int [][] B ) //Supone que A y B son del mismo tamaño int [][] result nuevo int [A.longitud][A.longitud] para i 0 hasta A.longitud-1 para j 0 hasta A.longitud-1 result [i][j] A[i][j] + B[i][j] regresa result Los algoritmos mostrados anteriormente pueden escribirse dentro de una clase en Java, por ejemplo: import Teclado; /** * Ejemplos de matrices */ class EjemploMatrices //No existen datos miembro /** * Lee una matriz de tamaño MAX por MAX, donde MAX se pasa como parámetro */ static int [][] leematriz(int MAX) Pág. 11

12 int [][] matriz = new int [MAX][MAX]; for (int i = 0; i < MAX; i++) for (int j = 0; j < MAX; j++) System.out.print ("matriz [" + i + "][" + j + "] = " ); matriz[i][j] = Teclado.readInt (); return matriz; /** * Imprime los valores de una matriz */ static void escribe (int [][] matriz) for (int i = 0; i < matriz.length; i++) for (int j = 0; j < matriz.length; j++) System.out.print (matriz [i][j] + " " ); System.out.println(); static int [][] suma (int [][] A, int [][] B ) int [][] result = new int [A.length][A.length]; for (int i = 0; i < A.length; i++) for (int j = 0; j < A.length; j++) result [i][j] = A[i][j] + B[i][j]; return result; public static void main (String [] a) // EjemploMatrices ejem = new EjemploMatrices (); //Se crea y se lee una matriz int [][] A = leematriz (2); //Se crea y se lee otra matriz int [][] B = leematriz (2); //Se suman A y B dejando el resultado en C int [][] C = suma (A,B); System.out.println ("Matriz A"); escribe (A); System.out.println ("Matriz B"); escribe (B); System.out.println ("La suma de A y B es"); escribe (C); A continuación se muestra una ejecución: Pág. 12

13 Pág. 13

14 Cuadrado Mágico En la pintura Melancholia I del matemático y artista alemán Albrecht Dürer, aparece un cuadrado mágico Abajo aparece aislado el cuadrado mágico. Qué propiedades debe tener un cuadrado para ser mágico? Pág. 14

15 lsuma renglones suma columnas suma diagonal suma antidiagonal la suma debe ser (n 3 +n) / 2 clase CuadradoMágico int [] elem int n //número de elementos... iint sumadiagonal () int suma 0 para i 1 hasta n suma suma + elem [i][i] regresa suma iint sumaantidiagonal () int suma 0 para i 1 hasta n suma suma + elem [ ][ ] regresa suma... Grado de similaridad: Pág. 15

16 real gradosimilaridad (bool [][] original) int diferentes 0 para i 0 hasta longitud ()-1 para j 0 hasta longitud () 1 si original [i][j] <> letra [i][j] entonces diferentes ++ regresa (diferentes 100) /(n*n) Ejercicios: 1. Escribir una clase que lea una cadena (String) y construya un arreglo donde se almacena la frecuencia de las letras de la cadena 2. Declare una clase que permita representar los siguientes datos de un automóvil: dueño, marca, modelo y placas. Además, deberá tener 2 funciones constructoras y una función para escribir los datos del automóvil. 3. Utilizando la clase anterior construya un arreglo de automóviles y escriba una función que permita der cuál marca es la más popular 4. Escriba una función que multiplique dos matrices 5. Escriba una función que determine la suma de todos los elementos de una matriz Ejercicio de programación (Programa) Implemente en Java la clase EjemploVector vista en clase. Implemente en Java una clase que permita der si un cuadrado es mágico Pág. 16

17 3.2 Listas lineales Listas Lineales En la vida diaria frecuentemente se utilizan expresiones como 'lista de alumnos', 'lista de equipos de football', 'lista de espera', etc., para enumerar elementos en un cierto orden. Así, por ejemplo, se orden alumnos por su nombre o equipos de football por el número de partidos que han ganado o personas que esperan recibir un servicio según el orden en que se presentaron. Cuando se trata de resolver un problema, por lo general resulta conveniente utilizar un modelo matemático adecuado para su representación. Matemáticamente, una lista es una secuencia que contiene cero o más elementos de un mismo tipo. De esta forma: a 1, a 2,..., a n n >0 indica que una lista está formada por n elementos. Si n=0, se dice que la lista está vacía, es decir, no contiene elementos. Si n>0, se dice que a 1 la cabeza de la lista, es decir, el primer elemento de la lista. Al último elemento de la lista, a n, se le conoce como la cola de la lista. Las listas poseen la propiedad de que sus elementos se encuentran linealmente ordenados de acuerdo a su posición (a i está en la posición i de la lista), de esta forma, decimos que a i precede a a i+1 para i = 1,2,...,n-1 y a i-1 está después de a i-1 para i = 1,2,..,n-1. El tipo de datos abstracto (TDA) lista Para formar el tipo de datos abstracto (TDA) lista, se debe definir su conjunto de operaciones. En este caso como en algunos otros, el conjunto de operaciones depende de la aplicación con la que se esté trabajando. A continuación se presenta un conjunto de operaciones que pueden realizarse con el TDA lista. Función lista () bool vacía () void inserta (Objeto x) void borra (Objeto x) int busca (Objeto x, bool exito) int anterior (Nodo p) Descripción Crea una lista vacía. De si existen o no elementos en la lista Inserta en la lista el elemento x en la posición que conserva el orden de la lista. Elimina el elemento x de la lista De la posición donde se encuentra el elemento x dentro de la lista, en caso de que exista; en caso de que no exista, lo señalara e indica en qué posición debería estar si existiese. La variable boolena éxito sirve para der cuándo el elemento forma o no parte de la lista. De la posición que se encuentra antes de la Pág. 17

18 int cola () Listas Lineales posición p de la lista. De la posición donde se encuentra el último elemento de la lista. La forma en la cual suele representarse el TDA lista en una computadora es por medio de asignación estática de memoria (representación secuencial), o por medio de asignación dinámica de memoria (representación ligada). Cada una de ellas tiene ventajas o desventajas sobre la otra. A continuación se desarrollan para su estudio Representación secuencial Para representar en memoria contigua una lista, se puede utilizar un arreglo, en el que cada celda sea capaz de almacenar un elemento de la lista, y un índice que señale el número de elementos almacenados. La forma de representar una lista en representación secuencial es la siguiente: clase Lista Objeto info [] int último Lista () bool vacía () void insertar (Objeto x) void borrar (Objeto x) bool buscar (Objeto x) donde Objeto es el tipo de información con el cual trabajará la lista (entero, real, booleano, cadena, registro, o bien alguna otra clase). Suponga que se desea almacenar la lista de alumnos de Estructura de datos (llamada ListaEst), con tres calificaciones de exámenes parciales y su promedio. Además, se desea que la lista se encuentre en orden alfabético. En este caso, la clase alumno podría ser: clase alumno Cad Nombre real E1, E2, E3 Cad prom //Nombre del alumno //Calificación de 3 exámenes //Calificación numérica del promedio de exámenes de esta forma, la lista se vería como: Pág. 18

19 fig Operaciones sobre una lista en representación secuencial Crear: Para crear una lista, lo único que debe hacerse es inicializar el índice que señala el número de registros almacenados. Así, la función constructora por defáult podría ser: Lista () //crea una lista vacía último 0 info nuevo Objeto [MAX] Vacía: El procedimiento anterior sirve como guía para escribir la función que de si una lista se encuentra vacía: bool vacía () //regresa verdadero si la lista se encuentra vacía, en otro caso regresa falso vacía último = 0 Insertar: Para insertar un nuevo estudiante en nuestra lista, primero debe encontrarse la posición en el arreglo donde colocar el objeto y mover hacia abajo un lugar a todos aquellos objetos que se encuentren abajo de él para que la lista continúe siendo ordenada. Por ejemplo, si se incorpora Guillermo en la lista de estudiantes de la fig. 1, ListEst sería: Pág. 19

20 fig. 2 Note que el problema de mantener una lista ordenada, requiere algo más que un algoritmo de ordenación. De manera general, el algoritmo para insertar un elemento x en una lista es el siguiente: void inserta (Objeto x) //Inserta el elemento x en la lista de tal forma que el orden persista //busca la posición donde debe ir el elemento p busca (x,exito) si exito entonces //el elemento se encuentra error (el elemento se encuentra) otro //el elemento debe insertarse si ultimo >= Máximo entonces error (No hay espacio) otro moverabajo (L,p) //recorre hacia abajo los elementos info[p] x //pone la información A continuación se desarrollan los métodos utilizados para insertar un elemento: void moverabajo (int p) //recorre una posición hacia abajo a todos los elementos que se //encuentran a partir de la posición p último++ //se aumenta el número de elementos aux último +1 Pág. 20

21 mientras aux > p info[aux] info[aux-1] aux-- //la información se recorre un lugar //hacia abajo Listas Lineales Buscar: int busca (Objeto x; var exito:booleano) //busca el elemento X en la lista y regresa la posición donde se encuentra //en caso de que el elemento no forme parte de la lista, regresa la posición //donde debería encontrarse, la búsqueda se realiza de arriba hacia abajo //con ayuda de un centinela, colocándola una posición debajo de donde // la lista i 0 //i toma el valor del último índice de la lista exito verdadero info [MAXIMO] x //variable centinela mientras info[i] < x i-- si info[i] <> x or i = MAXIMO-1entonces exito falso i++ busca i El procedimiento para insertar un nuevo elemento en una lista que se ha desarrollado, consiste en agregar el elemento en la posición que conserva el orden alfabético o numérico de sus elementos. Sin embargo, en algunas aplicaciones el orden que debe tomarse en cuenta puede ser otro, como por ejemplo el orden de llegada. Borrar: Considere ahora cómo eliminar un elemento de una lista. Existen dos formas representativas de hacerlo. a) La primera consiste en buscar el elemento que se desea eliminar y dejar en blanco la celda que lo contiene, o bien marcarla como borrada. Por ejemplo, si deseamos eliminar a Luis, el arreglo de estudiantes mostrado en la fig. 1, quedaría como: Pág. 21

22 fig. 3 Las tres principales desventajas que se presentan en este tipo de esquema son: 1. Puede ocurrir que la última posición del arreglo esté ocupada y se quiera insertar un nuevo elemento que es mayor que el valor del elemento que se encuentra en la última celda del arreglo. En este caso no se puede insertar este valor, aunque existan celdas vacías en el arreglo. Esto puede solucionarse introduciendo un procedimiento de reorganización o reacomodo que junte todas las casillas ocupadas, dejando al final aquellas que no contienen información, cuando sea necesario. Lo cual es costoso. 2. El procedimiento para buscar un elemento deberá ver todas las casillas, aún cuando no estén ocupadas. 3. El procedimiento para insertar un nuevo elemento deberá modificarse para que cuando la posición deseada se encuentre vacía lo inserte en esa casilla y no recorra las posiciones hacia abajo. b) El segundo esquema que se presenta para borrar un elemento de una lista en representación secuencial, consiste en buscar la posición donde se encuentra el elemento y recorrer todos los elementos que están debajo de él una posición hacia arriba. Por ejemplo, si se desea eliminar a Luis de la lista mostrada en la figura 1, se obtendría: fig. 4 El algoritmo para eliminar un elemento de una lista dada, que utiliza el segundo esquema, se Pág. 22

23 muestra a continuación: Listas Lineales void borra (tipoinfo x) //elimina un elemento de una lista, si es que se encuentra p busca (x,exito) si exito entonces error (el elemento no se encuentra) otro MoverArriba (p) último último-1 //se manda buscar el elemento //se recorren una posición hacia arriba //todos los elementos a partir de p //disminuye el número de elementos void MoverArriba (int p) //recorre una posición hacia arriba los elementos que se encuentran a partir //de la posición p de la lista aux p mientras aux < último info[aux] info[aux+1] aux ++ Nótese que no es necesario limpiar la última celda que estaba ocupada antes de eliminar un elemento. Esto se debe a que nunca se tendrá acceso a esa celda de memoria mientras no se inserte un nuevo elemento, momento en que esa localidad de memoria será reasignada con un nuevo valor Representación ligada Existen aplicaciones en las cual es el número de elementos cambia dinámicamente durante la ejecución del algoritmo, (i.e. se realizan inserciones y/o eliminaciones). Es fácil ver que cuando se inserta o elimina un elemento que se encuentra a mitad de la lista es necesario mover la mitad de los elementos o peor aun cuando se inserta o elimina al principio de la lista, donde se necesitan mover todos los elementos; esto implica mucho trabajo, es decir es costoso. Otro inconveniente que existe cuando se representa una lista en un arreglo, es que en algunas ocasiones es muy difícil o imposible predecir el número de elementos que van a existir. La solución a esto podría ser reservar un espacio de memoria mucho mayor que el que se considera podría necesitarse. Esta deficiencia aunque es inherente a los arreglos, se Pág. 23

24 ve reflejada en una ineficiencia en cuando al espacio de memoria requerido. Listas Lineales Como puede observarse las listas en representación secuencial tienen un alto costo tanto en complejidad temporal como en complejidad espacial. Una solución a este problema es el uso de la representación ligada o dinámica, donde cada elemento es representado como una entidad por separado y todos los elementos se conectan a través de referencias. Listas ligadas El problema de mantener una lista ordenada en un arreglo, requiere de mover datos cuando se realizan inserciones y borrados. Estos movimientos podrían eliminarse si cada elemento indicara que elemento es el que se encuentra después de él. De esta forma, no es necesario considerar la noción natural que tenemos, de que algo se encuentra ordendo, si físicamente se encuentra ordenado. Conceptualmente podemos dibujar una lista de la siguiente forma: Una lista en representación ligada, es un conjunto de nodos, donde cada uno contiene al menos dos datos miembros, el primer sirve para guardar la información que se desea y el segundo sirve para saber quién es el elemento que se encuentra después de él. De esta forma podemos considerar que cada elemento de la lista un objeto de la siguiente clase: clase Nodo //datos miembro Objeto info Nodo liga //constructoras Nodo () Nodo nil Nodo (Objeto datos) info datos liga nil Nodo (Objeto datos, Nodo l) info datos liga l //Imprime la información del nodo Pág. 24

25 void escribe () De tal forma que la clase lista quedaría definida como: clase Lista //dato miembro Nodo cabeza //Función constructora Lista () //funciones miembro bool vacía () bool busca (Objeto o, Nodo pos) void borrar (Objeto o) void inserta (Objeto o) Operaciones sobre una lista en representación ligada Al igual que en la representación secuencial de una lista, las operaciones que se desarrollan, consideraran que los elementos de la lista se encuentran en orden ascendente. Crear: Cuando se desea crear una lista, esta debe de encontrarse vacía. Así: Lista () //construye una lista vacía this nil La forma gráfica en que representaremos que una lista está vacía es: Vacía: De forma semejante para der si una lista está o no vacía: bool vacía () //regresa verdadero si la lista se encuentra vacía, en otro caso //regresa falso Pág. 25

26 vacía this = nil Listas Lineales Buscar: En muchas ocasiones es necesario saber si un elemento se encuentra y la posición que ocupa en la lista, de esta forma, por medio de una referencia puede conocerse el elemento que lo contiene; en caso de que el elemento que se busca no se encuentre, se regresa la posición del elemento que debería ir después de él. Aprovechando el hecho de que la lista se encuentra ordenada, el algoritmo puede escribirse como: Nodo busca(objeto x, booleano exito) //busca el objeto x en la lista; en caso de que exista regresa una referencia //al elemento que lo contiene; en caso contrario, regresa una //referencia al elemento que debería de ir después de él aux cabeza //aux sirve para moverse a través de la lista //mientras no se termine la lista y la información del nodo sea //menor que la buscada se avanza al siguiente nodo mientras aux <> nil & aux.info < x aux aux.liga éxito aux <> nil & aux.info = x busca aux Insertar: Cuando se desea insertar un elemento en una lista, lo primero que debe hacer es establecer si se permitirá o no elementos repetidos. Suponga que no se desea tener elementos repetidos. Así, lo primero que debe hacerse es der si el elemento se encuentra o no. En caso de que se encuentre, se invoca al procedimiento de error que tomará las acciones pertinentes, dependiendo de la aplicación. Por otro lado si el elemento no forma parte de la lista, debe ser incorporarlo a la lista. Para estudiar cómo insertar un elemento en una lista, se dividirá en los siguientes casos. a) La lista en la cual se desea insertar un elemento se encuentra vacía. b) El elemento que se desea insertar, deberá ser la cabeza de la lista. c) El elemento que se desea insertar, deberá ser la cola de la lista. d) El elemento que se desea insertar, deberá ocupar una posición intermedia. En cada caso, suponga que el elemento no se encuentra, y que esto fue dedo por el procedimiento busca anterior, que fue invocado como: Pág. 26

27 posterior busca (x,exito) a) La lista en la cual se desea insertar un elemento se encuentra vacía. En este caso se debe: 0. Der que la lista se encuentra vacía. 1. Crear un nodo cuya información sea la que deseamos insertar y cuya liga apunte a nil, ya que no existen más elementos. 2. La lista ahora debe apuntar a este nuevo elemento. Después de insertar el nodo, gráficamente la lista se vería como: Las acciones enumeradas anteriormente, pueden escribirse en pseudocódigo como: si vacía () entonces Nuevo nuevo Nodo (x) cabeza Nuevo b) El elemento que se desea insertar, deberá ser la cabeza de la lista. En este caso se debe: 0. Der que debe ser la cabeza de la lista. 1. Crear un nodo cuya información sea la que deseamos insertar. 2. La liga del nuevo elemento, deberá apuntar a posterior (i.e., la cabeza actual de la lista. 3. La lista apunta ahora al nuevo elemento. Considere estas acciones de manera gráfica: Suponga que se desea insertar el elemento b en la siguiente lista; después de invocar a busca, la lista se ve como: Pág. 27

28 Se crea un nodo cuya información sea b : La liga del nuevo elemento deberá referenciar a la cabeza de la lista: Se cambia el valor de la cabeza para que apunte al nuevo primer elemento de la lista: Una forma de escribir esto es pseudocógigo, puede ser la siguiente: Para der que el elemento x debe insertarse como la cabeza de la lista L, puede preguntarse si el elemento que es referenciado por posterior es el elemento al cual referencia la lista, así: si posterior = cabeza entonces nuevonodo nuevo Nodo (x) nuevonodo.liga cabeza cabeza nuevonodo c) El elemento que se desea insertar, deberá ser la cola de la lista. En este caso se debe: 0. Der que debe ser la cola de la lista. 1. Crear un nodo cuya información sea la que deseamos insertar 2. La liga del nuevo elemento, deberá apuntar a nil, ya que después de él no hay más elementos. 3. Der el elemento que se encuentra a la izquierda de posterior (nodoanterior). 4. Cambiar la liga de nodoanterior, para que ahora apunte al nodo que deseamos insertar. Pág. 28

29 Gráficamente: Suponga que se desea insertar el elemento c en la siguiente lista; después de invocar a busca, la lista se ve como: Se crea un nodo cuya información es c y cuya liga apunta a nil: Der quién es actualmente la cola de la lista: por último: En pseudocódigo: En este caso después de invocar a busca, posterior tendrá el valor de nil. Para encontrar quién es la cola de la lista se construye una función que regrese una referencia al elemento que es la cola de la lista, note que la liga del elemento que es la cola de la lista siempre apunta a nil: Pág. 29

30 Nodo cola () aux cabeza mientras aux.liga <> nil aux aux.liga regresa aux // se recorre la lista Listas Lineales Así, el pseudocódigo para insertar un elemento x como la cola de la lista L: si posterior = nil entonces nuevonodo nuevo Nodo (x) anterior cola () anterior.liga nuevonodo d) El elemento que se desea insertar, deberá ocupar una posición intermedia. En este caso se debe: 1. Crear un nodo cuya información sea la que se desea insertar. 2. La liga del nuevo elemento, deberá apuntar al nodo posterior (encontrado por el procedimiento busca). 3. Der el elemento que se encuentra a la izquierda de posterior (nodo Anterior). 4. Cambiar la liga del nodoanterior para que ahora apunte al nodo que se desea insertar. A continuación se presenta un ejemplo: Suponga que se desea insertar un nodo cuya información sea "e" en la siguiente lista; después de invocar a busca, la lista se ve como: Se crea un nodo cuya información es e y cuya liga apunte a posterior: Pág. 30

31 Se de quién es nodoanterior: Se modifica la liga de nodoanterior para que apunte a Nuevo: En pseudocódigo: nuevonodo nuevo Nodo (x) nuevonodo.liga posterior nodoanterior anterior (posterior) nodoanterior.liga nuevonodo El algoritmo para encontrar el nodo anterior de una cierta posición y el algoritmo para Pág. 31

32 encontrar la cola de la lista son muy parecidos y se dejan como ejercicio al lector. Listas Lineales Considere ahora un algoritmo que inserte un nodo cuya información es x, en una lista L, en cualquiera de los casos anteriores. Nótese que: i) En el caso que el elemento no se encuentre en la lista, siempre se crea un nodo con la información que se desea incorporar. ii) Las acciones que se realizan cuando la lista está vacía y cuando el nuevo elemento debe insertarse como la cabeza de la lista son las mismas. void inserta (Objeto x) //Inserta el elemento x en la lista, si no existe en ella, la posición en la //cual se inserta conserva el orden ascendente de la lista posterior busca (x,exito) si exito entonces error ( El elemento ya se encuentra ) otro nuevonodo nuevo Nodo (x, posterior) //la lista está vacía o el elemento debe insertarse como la cabeza si posterior = cabeza entonces cabeza nuevonodo otro nodoanterior anterior (posterior) nodoanterior.liga nuevonodo Borrar: La forma en la cual se elimina un elemento de una lista, es semejante a la inserción; después de localizar al elemento, si es que este se encuentra pueden considerarse varios casos, en donde el elemento que se desea eliminar dentro de la lista es: a) el único b) la cabeza c) la cola d) un nodo intermedio De esta forma la primera parte del algoritmo sería: nodo busca (x,exito) si exito entonces error (el elemento no existe) Pág. 32

33 otro a or b or c or d Listas Lineales donde cada caso es mutuamente excluyente. a) El elemento que se desea eliminar es el único de la lista. En este caso la lista deberá quedar vacía: si nodo=cabeza & nodo.liga= nil entonces cabeza nodo.liga b) El elemento que deseamos eliminar es la cabeza de la lista. Aquí se debe indicar que la lista empezará en el elemento que se encuentra a la derecha del elemento a eliminar. otro si nodo = cabeza entonces cabeza nodo.liga c) El elemento que se desea eliminar es la cola de la lista. En este caso se debe indicar que el elemento que se encuentra a la izquierda del elemento a eliminar deberá ser la cola, esto es que su liga referencie a nil. otro si nodo.liga = nil entonces nodoanterior anterior (nodo) nodoanterior.liga nil // equivalente a nodo.liga d) El elemento que se desea eliminar es un nodo intermedio. Aquí el elemento que se encuentra a la izquierda del elemento que se desea eliminar deberá referenciar al elemento que se encuentra a la derecha del que se desea elimina. Así: otro nodoanterior anterior (nodo) nodoanterior.liga nodo.liga Ahora se escribirá un algoritmo para eliminar un elemento en una lista, que tome en cuenta Pág. 33

34 los cuatro casos desarrollados anteriormente, para esto note que: i) El caso a) y b) son el mismo ii) El caso c) y d) son el mismo Con las observaciones anteriores el algoritmo para eliminar un elemento x de una lista es el siguiente: void borra (Objeto x) //elimina el elemento x de la lista, si se encuentra nodo busca (x,exito) si exito entonces error (El elemento no se encuentra) otro si nodo = cabeza entonces cabeza nodo. liga otro nodoanterior anterior (nodo) nodoanterior.liga nodo.liga Las ventajas de la representación ligada sobre la representación secuencial son: aumentan y disminuyen a lo largo de su vida. mayor flexibilidad en las operaciones. Las desventajas son: se requiere mayor espacio de memoria para guardar un elemento. si se quiere tener acceso al elemento 30, se necesita empezar en la cabeza de la lista y recorrer 29 referencias, una a una; lo que con arreglos puede hacerse directamente Ejemplos Pág. 34

35 Ejemplo 1: Número de elementos de una lista Listas Lineales Crear un algoritmo que cuente el número de elementos de una lista ligada. Este problema puede resolverse recorriendo toda la lista, esto es pasando a través de cada uno de sus elementos e irlos contando, para esto utilizaremos una variable auxiliar de tipo Nodo (p) que ayude a recorrer la lista y una variable entera (numelem) para contabilizar el número de elementos que existen en la lista. int contar () p cabeza numelem 0 mientras p <> nil numelem++ p p.liga contar numelem //referencia al primer elemento de la lista //se inicializa el número de elementos // mientras no se termine la lista //p avanza al siguiente elemento de la lista Ejemplo 2: Dividir una lista en dos Escribir un algoritmo que cree dos listas a partir de una dada, de tal forma que el primero, el tercero, el quinto, etc., elementos pertenezcan a una lista; y el segundo, el cuarto, el sexto, etc., pertenezcan a la otra lista. Por ejemplo, suponga que se tiene la siguiente lista: El algoritmo creara dos nuevas listas L1 y L2 como se muestra en la siguiente figura: Pág. 35

36 El algoritmo para resolver este problema surge de manera natural, lo único que hay que tener en cuenta es cuando la lista contiene un número impar de elementos, ya que en este caso no agregaremos ningún elemento a la segunda lista. void divide (Lista L1, Lista L2) L1 nueva Lista () //se crea la lista vacía L1 L2 nueva Lista () //se crea la lista vacía L2 p1 L1.cabeza //p1 es la referencia a L1 p2 L2.cabeza //p2 es la referencia a L2 p L.cabeza //p es la referencia a L mientras p <> nil //mientras no se termine de recorrer la lista //se copia el elemento referenciado por p en L1 nuevonodo nuevo Nodo (p.info, nil) si p1 = nil entonces L1.cabeza nuevonodo otro p1.liga nuevonodo p1 nuevonodo p p.liga //si la lista contiene elementos por copiar se copia el referenciado //por p en L2 si p <> nil entonces nuevonodo nuevo Nodo(p.info, nil) si p2 = nil entonces L2.cabeza nuevonodo otro p2.liga nuevonodo p2 NuevoNodo p p.liga Note que las partes donde se inserta el elemento a cada una de las listas es igual, excepto que se agrega el elemento en distintas listas, esto sugiere la creación de un método, al cual llamaremos agrega, de tal forma el procedimiento divide, se vería como: void divide (Lista L1,Lista L2) Pág. 36

37 L1 nueva Lista () //se crea la lista vacía L1 L2 nueva Lista () //se crea la lista vacía L2 p1 L1.cabeza //p1 es la referencia a L1 p2 L2.cabeza //p2 es la referencia a L2 p L.cabeza //p es la referencia a L mientras p <> nil //mientras no se termine de recorrer la lista agrega (p,l1,p1) si p <> nil entonces agrega (p,l2,p2) void agrega (Nodo p, Lista nuevalista, Nodo colanl) //La información que contiene la referencia p es insertada al final de la // lista nuevalista nuevonodo nuevo Nodo(p.info, nil) //se crea un nodo si nuevalista.vacía () entonces nuevalista.cabeza nuevonodo otro //si la lista no es vacía se liga con Nuevo colanl.liga nuevonodo colanl nuevonodo //el nuevo elemento insertado es ahora //la cola de Nueva Lista p p.liga //p referencia al siguiente elemento Listas Lineales Pág. 37

38 3.3 Listas doblemente ligadas Listas Lineales Cuando se trabaja con listas ligadas el acceso al nodo que se encuentra después de cualquier otro resulta conveniente; pero no así, cuando se trata de accesar al nodo que se encuentra antes de él. Considere los métodos posterior (Nodo p), que devuelve una referencia al nodo que se encuentra después del nodo p, y anterior (Nodo p), que devuelve una referencia al nodo que se encuentra antes del nodo p. Para acceder a la posición que sigue a p en una lista, basta con acceder a su liga: Nodo posterior (Nodo p) si p = nil entonces error (Lista vacía) otro posterior p.liga Cuando se desea acceder a la posición previa de p es necesario recorrer toda la lista, hasta una posición antes de p, es decir hasta que la liga del elemento actual sea p: Nodo anterior (Nodo p) // Supone que el Nodo p existe dentro de la lista aux cabeza ant nil mientras aux <> p ant aux aux aux.liga Como puede observarse el trabajo realizado para obtener el nodo anterior es mucho mayor que el trabajo para obtener el nodo posterior, esto se debe a que se tiene una referencia al nodo posterior; siguiendo este mismo esquema podría tenerse otra referencia al nodo anterior. De esta forma un nodo estaría compuesto por tres datos miembros: info, para almacenar un objeto ligader, referencia al nodo anterior ligaizq, referencia al nodo posterior de forma gráfica: Pág. 38

39 En una lista doblemente ligada cada nodo no sólo tiene una referencia al siguiente sino también una referencia al nodo anterior. En forma esquemática una lista doblemente ligada se vería como: Como puede observarse, la ventaja de las listas doblemente ligadas es el acceso rápido y directo tanto al elemento siguiente como al posterior de una posición deda de la lista. Por tanto, conviene utilizarlas cuando se necesita recorrer una lista en ambas direcciones. Aunque las listas doblemente ligadas utilizan más espacio que una lista ligada, sus operaciones pueden ejecutarse más eficientemente y esto compensa el espacio extra requerido. La clase nodo para una lista doblemente ligada es: clase Nodo Objeto info Nodo ligader, ligaizq Nodo (Objeto obj) info obj ligader ligaizq nil Nodo (Objeto obj, Nodo izq, Nodo der) info obj ligaizq izq ligader der void escribe () //imprime la información del nodo Operaciones sobre una lista doblemente ligada en representación ligada clase ListaDobleLigada Nodo cabeza ListaDobleLigada () Nodo busca (Objeto x, bool éxito) void inserta (Objeto x) Pág. 39

40 void borra (Objeto x) Crear: El procedimiento para crear una lista doblemente ligada es similar a la función constructora de una lista ligada: ListaDobleLigada () cabeza nil Vacía: De forma semejante el método para der si una lista doblemente ligada está o no vacía es: bool vacía () //regresa verdadero si la lista se encuentra vacía, en otro caso regresa falso vacía cabeza = nil Buscar: El algoritmo para buscar un elemento en una lista doblemente ligada es semejante al algoritmo de búsqueda en una lista ligada, pero aprovechando las ventajas que se tienen, cuando el elemento que se busca no se encuentra se regresará la posición del elemento que debería ir antes de él. Por ejemplo, suponga la siguiente lista y que se desea buscar al elemento 3, el cual no forma parte de la lista: el método regresará una referencia al nodo cuya información es 2. Para desarrollar este algoritmo considere que la lista doblemente ligada está ordenada en forma creciente y que no existen elementos repetidos. Nodo busca (Objeto x, var bool éxito) //busca un elemento x en la lista; en caso de que exista, regresa una //referencia al elemento que lo contiene; en caso contrario, regresa un Pág. 40

41 //referencia al elemento que debería ir antes que él si cabeza = nil entonces // la lista es vacía aux nil éxito falso otro aux cabeza mientras aux.ligader <> nil & aux.info < x aux aux.ligader //se avanza un elemento éxito aux.info = x si aux.info > x entonces aux aux.ligaizq regresa aux Insertar: Listas Lineales El algoritmo para insertar que será desarrollado no permitirá elementos repetidos y conservará un orden lineal en sus elementos. El algoritmo para insertar un nodo en una lista doblemente ligada será dividido en los siguientes casos diferentes: a) La lista en la cual se desea insertar el elemento se encuentra vacía b) El elemento que se desea insertar deberá ser la cabeza de la lista c) El elemento que se desea insertar deberá ser la cola de la lista d) El elemento que se desea insertar deberá ocupar una posición intermedia En cada caso, se supondrá que el elemento no se encuentra y que esto fue dedo por el método busca, anteriormente desarrollado, que regresa la posición del nodo que debería ir a la izquierda (llamado ant) del que se desea insertar, esto es: ant busca (x, éxito) si éxito entonces error (el elemento se encuentra) otro a or b or c or d donde a, b, c y d son mutuamente excluyentes. a) La lista en la que se desea insertar se encuentra vacía En este caso se debe: Pág. 41

42 0. Der que la lista se encuentra vacía 1. Crear un nodo con la información que se desea insertar y cuyas ligas referencien a nil 2. Referenciar la cabeza a este nuevo nodo Después de insertar el nodo, gráficamente la lista deberá ser: Las acciones enumeradas anteriormente en forma de pseudocódigo son: si vacía () entonces nodonuevo nuevo Nodo (x) cabeza nodonuevo b) El elemento que se desea insertar deberá ser la cabeza de la lista En este caso se debe: 0. Der que debe ser la cabeza de la lista 1. Crear un nodo que contenga al objeto que se desea insertar, su liga izquierda deberá referenciar a nil y su liga derecha a la cabeza actual de la lista 2. La liga izquierda de la cabeza deberá apuntar al nuevo nodo 3. La cabeza deberá referenciar al nuevo elemento Suponga que se desea insertar el elemento 1 en la siguiente lista: Las acciones anteriores de manera gráfica son: Se crea un nuevo nodo cuya información sea 1, cuya liga izquierda sea nil y cuya liga derecha referencie a la cabeza de la lista: Pág. 42

43 Se cambia el valor de la liga izquierda de la cabeza para que referencie al nuevo elemento y finalmente se indica que el nuevo elemento es ahora la cabeza de la lista, esto es: De manera más formal estas acciones son: otro si ant = nil entonces nodonuevo = nuevo Nodo (x, nil, cabeza) cabeza.ligaizq nodonuevo cabeza nuevonodo c) El elemento que se desea insertar deberá ser la cola de la lista En este caso se debe: 0. Der que el nuevo elemento deberá ser la cola de la lista 1. Crear un nodo cuya información sea la que se desea insertar, su liga derecha deberá referenciar a nil, ya que después de él no deben existir más elementos, su liga derecha deberá apuntar al nodo anterior, que en este caso es la cola de la lista actual 2. Cambiar la liga derecha del nodo anterior para que ahora referencie al nodo que se desea insertar Gráficamente: Suponga que se desea insertar un elemento cuya información sea 7 en la siguiente lista; después de invocar a busca: Pág. 43

44 Se crea un nodo cuya información es 7 y cuya liga derecha referencie a nil. La liga derecha del nodo anterior deberá referenciar al nuevo elemento, de lo cual se obtiene la siguiente lista: En pseudocódigo, las acciones para insertar un elemento como la cola de una lista son: otro si ant.ligader = nil entonces nuevonodo = nuevo Nodo (x, ant, nil) ant.ligader nuevonodo d) El elemento que se desea insertar deberá ocupar una posición intermedia Este caso es el más general de todos y se deberá: 0. Considerar que no fue ninguno de los casos anteriores 1. Crear un nodo cuya información contenga al objeto que se desea almacenar, su liga izquierda deberá referenciar al nodo anterior y su liga derecha al elemento que se encuentra a la derecha del anterior 2. La liga izquierda del nodo que se encuentra a la derecha del anterior deberá referenciar al nuevo nodo 3. La liga derecha del nodo anterior deberá referenciar al nuevo elemento A continuación se presenta un ejemplo. Suponga que se desea insertar un 4 en la siguiente lista: Pág. 44

45 Primero se crea un nodo cuya información sea 4, con liga izquierda a anterior y liga derecha a la referencia de la liga derecha del anterior: Por último, la liga izquierda de la liga derecha de anterior deberá referenciar al nuevo nodo y la liga derecha de anterior a nuevo. En pseudocódigo: otro nuevonodo nuevo Nodo (x, ant, ant.ligader) anterior.ligader.ligaizq nuevonodo anterior.ligader nuevonodo Ahora se desarrolla un algoritmo para insertar un elemento en una lista doblemente ligada de manera general, es decir, tomando en cuenta los cuatro casos desarrollados anteriormente; considere que: I. siempre que el elemento no forma parte de la lista se crea un nodo cuya información es la que se desea insertar y cuya liga izquierda referencia al nodo anterior, dedo por la función busca II. Los casos a y b son muy parecidos Pág. 45

46 III. Los casos c y d son muy parecidos void inserta (Objeto x) ant busca (x, éxito) si éxito entonces error (el elemento ya existe) otro nuevonodo nuevo Nodo (x, ant, cabeza) si ant = nil entonces si cabeza = nil entonces cabeza.ligaizq nuevonodo cabeza nuevo Nodo () otro nuevonodo.ligader ant.ligader si ant.ligader <> nil entonces ant.ligader.ligaizq nuevonodo ant.ligader nuevonodo Borrar: El algoritmo debe considerar que cuando se desea eliminar un elemento de una lista doblemente ligada este puede ser: a) el único elemento b) la cabeza de la lista c) la cola de la lista d) un nodo intermedio Para cada uno de estos casos puede suponerse que el elemento forma parte de la lista; lo cual fue dedo a través del método busca de la siguiente forma: nodo busca (x, éxito) si éxito entonces error (el elemento no se encuentra) otro a or b or c or d A continuación se presenta cada caso: Pág. 46

47 a) El elemento que se desea eliminar es el único de la lista Listas Lineales En este caso tanto la liga derecha como la izquierda del nodo referencian a nil y la lista deberá quedar vacía. Así: si nodo.ligaizq = nil & nodo.ligader = nil entonces cabeza nodo.ligader //que es igual a nil b) El elemento que se desea eliminar es la cabeza de la lista Aquí la lista deberá iniciar en el elemento que se encuentra a la derecha del nodo: otro si nodo.ligaizq = nil entonces cabeza nodo.ligader cabeza.ligaizq nil c) El elemento que se desea eliminar es la cola de la lista En este caso la liga derecha del elemento referenciado por la liga izquierda del elemento que se desea eliminar deberá referenciar a nil, esto es: otro si nodo.ligader = nil entonces nodo.ligaizq.ligader nil d) El elemento que se desea eliminar es un nodo intermedio En este caso, la liga derecha que se encuentra a la izquierda del nodo que se desea eliminar deberá referenciar al elemento de la derecha del nodo que debe eliminarse y, de forma semejante, la liga izquierda que se encuentra a la derecha del nodo que se desea eliminar deberá referenciar al elemento de la izquierda del nodo en cuestión, es decir: si nodo.ligaizq = nil & nodo.ligader = nil entonces cabeza nodo.ligader //que es igual a nil otro //B si nodo.ligaizq = nil entonces cabeza nodo.ligader cabeza.ligaizq nil otro si nodo.ligader = nil entonces //C nodo.ligaizq.ligader nodo.ligader otro //D nodo.ligaizq.ligader nodo.ligader nodo.ligader.ligaizq nodo.ligaizq Pág. 47

48 El algoritmo general para eliminar un nodo en una lista doblemente ligada, resulta ser elegantemente simple: void borra (Objeto x) nodo busca (x, éxito) si éxito entonces error (el elemento no existe) otro si cabeza = nodo entonces cabeza nodo.ligader si nodo.ligader <> nil entonces nodo.ligader.ligaizq nodo.ligaizq si nodo.ligaizq <> nil entonces nodo.ligaizq.ligader nodo.ligader Ejemplos: 1. Encontrar el i-ésimo nodo Encontrar el elemento que ocupa la posición i en una lista doblemente ligada: Nodo encuentra (int i) p cabeza numelem 1 mientras numelem < i & p <> nil p p.ligaizq numelem ++ si numelem = i & i <> 0 entonces encuentra p otro encuentra nil 2. Copiar una lista doblemente ligada Copiar la información almacenada en una lista doblemente ligada en otra lista doblemente ligada. Pág. 48

49 Lista clone () //crea una copia de la lista copial nueva Lista () refl cabeza refcopial copial.cabeza //se construye una nueva lista vacía //referencia a this mientras refl <> nil //mientras no se recorra toda la lista nuevonodo nuevo Nodo (refl.info, refcopial, nil) si refcopial = nil entonces copial.cabeza nuevonodo nuevonodo.ligaizq refcopial refcopial nuevonodo refl refl.ligader 3. Multiplicación de polinomios Recuerde con un ejemplo cómo se realiza la multiplicación de polinomios Listas Lineales 6x 6 + 8x 3 + 4x 2 + 2x + 1 X 3x 2 + x + 1 6x 6 + 8x 3 + 4x 2 + 2x + 1 6x 7 + 8x 4 + 4x 3 + 2x 2 + x 18x x x x 4 + 3x 2 18x 8 + 6x 7 + 6x x x x 4 + 9x 2 + 3x + 1 Como puede observarse, para realizar la multiplicación de dos polinomios, se toma el primer término de uno de los polinomios y se multiplica por todos los términos del otro polinomio, después se toma el segundo término del primer polinomio y se multiplica nuevamente por todos los términos del segundo polinomio y así sucesivamente hasta que se llega al último término del primer polinomio, el cual nuevamente se multiplica por cada uno de los términos del segundo polinimio. Del ejemplo puede verse que se obtiene un nuevo polinomio cada vez que se multiplica un nuevo término. Un polinomio puede representarse a través de una lista. Ejercicios Escribir un algoritmo para: 1. Intercalar dos listas doblemente ligadas ordenadas 2. Ordenar una lista ligada desordenada en forma creciente 3. Ordenar una lista doblemente ligada desordenada en forma creciente 4. Copiar una lista doblemente ligada Pág. 49