Unidad 5 Listas Enlazadas Bibliografía: Algoritmos y Estructuras de datos de Aguilar y Martinez. Unidad 9 Autor: Ing Rolando Simon Titiosky.

Fundamentos Teóricos Si en tiempo de Diseño del Algoritmo: Se conoce la cantidad de elementos a EnListar. –Podemos usar Organización Estática de Memoria: Arrays. Obliga en tiempo de Compilación a reservar la memoria a usar. Implementaciones mas rápidas: Ya se Gestionó la Memoria. Uso Ineficiente de Memoria: Una posición que no se utiliza no puede ser usada por nadie mas. Si no se conoce la cantidad de elementos a EnListar –Debemos usar Organización Dinámica: Listas Enlazadas. Colección de Nodos lógicamente uno detrás de otro. C/Nodo y se compone al menos de 2 campos –La información propiamente dicha –Un puntero al próximo elemento de la lista. Info Ptro Info Ptro Info Ptro Info Null Ptro CAB

Clasificación de Listas Enlazadas Apunta al PrimeroNullUltimo Nodo Forward y Backward Circular Forward Circular Forward y Backward ForwardRecorrido Eficiente 1 al sucesor 1al predecesor 1 al sucesor 1al predecesor 1 al sucesor# Enlaces del Nodo Circular Doblemente Enlazada Circular Simplemente Enlazada Doblemente Enlazada Simplemente Enlazada Se pueden implementar con Arrays o Punteros. Todas tiene Cabeza y Cola. –Una Lista Vacía tiene su Cabeza=Cola=Null Pueden almacenar cualquier tipo de información –Las inserciones se pueden realizar en cualquier punto de la lista Los elementos se insertan ordenados

Operaciones Típicas en Listas Inicialización o creación Insertar elementos en la lista –Al principio, al final –Antes o después de la posición i –Antes o después del elemento con la información x. Eliminar elementos en la lista –La cabeza, el final –El elemento de la posición i –El elemento con la información x. Buscar elementos en la lista –El elemento de la posición i –El elemento con la información x. Modificar –El elemento de la posición i –El elemento con la información x. Recorrer los Nodos de la Lista Comprobar si la lista esta vacía. Cantidad de elementos de una lista. Intercambiar dos elementos de la lista …

Especificación TAD Lista Simplemente Encadenada (SE) Se hace una Especificación básica de ejemplo. Aunque está siempre ligada al asunto que se quiera resolver. TAD Lista –(a1, a2, …ai,.., an) siendo n>=0; Si n=0 entonces Lista Vacia Sintaxis L Lista, x Lista, p puntero –ListaVacia(L): Inicializa la Lista L vacía. –EsVacia(L): Determina si L es vacía –Insertar(L, x, p): Inserta en la Lista L un nodo con el campo dato x, delante del nodo de dirección p –Localizar(L, x): Localiza en L, el nodo con campo de información x. –Suprimir(L, x): Elimina en L, el nodo con campo de información x. –Anterior(L,x): Devuelve el Nodo anterior al nodo con campo de información x. –….

Ejemplo Simple de Listas SE #include #define MX 99 typedef int Item; typedef struct Elemento {Item dato; struct Elemento* siguiente; } Nodo; void inserPrimero(Nodo** cabeza, Item entrada); Nodo* crearNodo(Item x);… Cargar una lista simplemente enlazada con números aleatorios hasta encontrar el número 0. Luego se muestran por pantalla solo aquellos que sean números pares.

Ejemplo Simple de Listas SE void main() {Item d; Nodo *cabeza, *ptr; int k; cabeza = NULL; /* lista vacía */ randomize(); for (d = random(MX); d; ) /*Bucle termina cuando se genera el número 0*/ {inserPrimero(&cabeza, d); d = random(MX); } for (k = 0, ptr = cabeza; ptr!=NULL; ptr = ptr -> siguiente) if (ptr -> dato%2 == 0) /* se recorre la lista para escribir los pares */ {printf("%d ", ptr -> dato); k++; printf("%c",(k%12 ? ' ' : '\n')); /* 12 datos por línea */ } printf("\n\n"); }

Ejemplo Simple de Listas SE Nodo* crearNodo(Item x) {Nodo *a ; a = (Nodo*)malloc(sizeof(Nodo)); /* asigna nuevo nodo */ a -> dato = x; a -> siguiente = NULL; return a; } void inserPrimero(Nodo** cabeza, Item entrada) {Nodo *nuevo ; nuevo = crearNodo(entrada); nuevo -> siguiente = *cabeza; *cabeza = nuevo; }

Grafica de Punteros Lista SE 6 Ptro 10 Null Ptro CAB 3 Ptro Nuevo 5 Null Nuevo=crearNodo(5) 6 Ptro 10 Null Ptro CAB 3 Ptro Nuevo 5 Nuevo–>Siguiente=*Cabeza 6 Ptro 10 Null Ptro CAB 3 Ptro Nuevo 5 *Cabeza=Nuevo

Inserción al Final de la Lista SE Es menos eficiente pues hay que recorrer toda la lista. Void inserFinal(Nodo** cabeza, Ítem entrada) { Nodo *ultimo; ultimo=*cabeza; if(ultimo==NULL) /*lista vacía*/ *cabeza=crearNodo(entrada); else{for(;ultimo–>siguiente;) ultimo=ultimo–>siguiente; ultimo–>siguiente=crearNodo(entrada); }

Algoritmo de Inserción de un Nodo entre 2 existentes SE 1.Asignar un nuevo nodo apuntado por el ptr nuevo Si la lista está vacía se lo inserta como primer Nodo. 2.Buscar la posición del nodo Después, que contiene el campo dato de referencia. Si no existe (posición o referencia) No se Inserta. 3.Hacer que el nuevo–>siguiente apunte al nodo Despues–>siguiente, o Null si es el último. 4.Hacer que despues–>siguiente apunte al nuevo 1 Ptro 6 DESPUES Ptro 10 Null Ptro CAB NUEVO

void insertan(Nodo** cabeza, Ítem testigo, Item entrada) {Nodo *nuevo, *después; nuevo = crearNodo(entrada); if (*cabeza == NULL) *cabeza = nuevo; else {int esta=0; después=*cabeza; while ((despues->siguiente != NULL) && !esta) {if (después–>dato !=testigo) despues=despues–>siguiente; else esta=1; } if (esta) /* Se enlasa el nuevo nodo */ {nuevo -> siguiente = despues -> siguiente; despues -> siguiente = nuevo; } Inserción de un Nodo entre 2 existentes 1 Ptro Null Ptro CAB 4 Nuevo Ptro Despues

Búsqueda Por Contenido Parámetros: –cabeza: cabeza de lista –destino: valor de referencia que se está buscando. Localiza un elemento por referencia del contenido. –Si lo encuentra devuelve su ptro. Sino devuelve NULL Nodo * localizar(Nodo*cabeza, Ítem destino) { Nodo *indice; for(indice=cabeza; indice!=NULL; indice=indice–>siguiente) if(destino==indice–>dato) return indice; return NULL; }

Búsqueda por Posición Parámetros: –cabeza: cabeza de lista –posición: posición de referencia que se esta buscando. Localiza un elemento por referencia a su posición dentro de la lista. –Si lo encuentra devuelve su ptro. Sino devuelve NULL Nodo * buscarPosicion(Nodo*cabeza, int posición) { Nodo *indice; int i; indice=cabeza; for(i=1; (i<posición) && (indice!=NULL);i++) indice=indice–>siguiente; return indice; }

Eliminar un Nodo de la Lista SE Se enlazará el nodo anterior con el siguiente al que se debe eliminar. void eliminar (Nodo** cabeza, Item entrada) {Nodo* actual = *cabeza; Nodo *anterior = NULL; int encontrado = 0; while ((actual!=NULL) && (!encontrado)) /* búsqueda del nodo y del anterior */ {encontrado = (actual -> dato == entrada); if (!encontrado) { anterior = actual; actual = actual -> siguiente; } if (actual != NULL) /* Enlace nodo anterior con siguiente. Si es NULL No existe elemento */ {if (actual == *cabeza) /* distingue entre el nodo cabecera o el resto de la lista */ *cabeza = actual -> siguiente; else anterior -> siguiente = actual -> siguiente; free(actual); }

Listas Doblemente Enlazadas (DE) Cada elemento contiene 2 ptro: hacia atrás y hacia delante en la Lista Las Operaciones son las mismas que para las Simplemente Enlazadas, pero aquí se pueden dar en ambas direcciones. El Borrado supone realizar los enlaces entre el ptr del nodo anterior con siguiente al que se desea eliminar. Null INS Inserción DEL Null Borrado

Creación de una Lista DE typedef struct tipoNodo {Item dato; struct tipoNodo* adelante; struct tipoNodo* atras; }Nodo; void main() { Nodo *cabeza,*ptr; int n; cabeza = NULL; /* lista vacía */ while (n!=0) {scanf (%i, &n); inserPrim(&cabeza,n); } Cargar una lista doblemente enlazada con números capturaods por consola hasta encontrar el número 0.

Nodo* crearNodo(Item x) {Nodo *a ; a = (Nodo*)malloc(sizeof(Nodo)); a -> dato = x; a -> adelante = a -> atras = NULL; return a; } void inserPrim(Nodo** cabeza, Item entrada) {Nodo* nuevo; nuevo = crearNodo(entrada); nuevo -> adelante = *cabeza; /*Apuntará al primer elemento antes de la INS*/ nuevo -> atras = NULL; /*Nuevo apuntará a Cabeza*/ if (*cabeza != NULL) (*cabeza)-> atras = nuevo; /* cabeza es ptr de ptr: esta referencia es */ /*hacia el ptr atrás del elemento al que apunta cabeza*/ *cabeza = nuevo; /*cabeza apuntará al nuevo primer elemento*/ } Creación de una Lista DE Null nuevo

Insertar entre elementos DE Ya se encontró el elemento anterior al punto de Inserción. Void insertar(Nodo **cabeza, Ítem entrada, Nodo *anterior) { Nodo *nuevo; if ((*cabeza)==NULL) || anterior==NULL) /*Principio de Lista*/ inserPrim(&cabeza, entrada); else {nuevo=crearNodo(entrada); nuevo–>adelante=anterior–>adelante; if (anterior–>delante!=NULL) /*No es fin de lista*/ /*atrás del siguiente apunta al nodo nuevo*/ (anterior–>delante)–>atrás=nuevo; anterior–>delante=nuevo; nuevo–>atrás=anterior; } Null ANTE Null nuevo

Eliminar entre Elementos DE void eliminar (Nodo** cabeza, Ítem entrada) { Nodo* actual = *cabeza; int encontrado=0; while ((actual!=NULL) && (!encontrado) /*Búsqueda del Nodo*/ {encontrado=(actual–>dato==entrada); if (!encontrado) actual=actual–>adelante; } if (actual !=NULL) /*enlazará el anterior con el siguiente. */ {if(actual==*cabeza) /*1er elemento de la lista */ {*cabeza = actual -> adelante; if (actual -> adelante != NULL) (actual -> adelante) -> atras = NULL; /*El nuevo 1er elemento de la lista debe tener el ptr atrás igual a NULL*/ } else if (actual -> adelante != NULL) /*Nodo Intermedio*/ {(actual -> atrás) -> adelante = actual -> adelante; (actual -> adelante) -> atras = actual -> atras; } else (actual -> atrás) -> adelante = NULL; /*Es el ultimo Nodo*/ free(actual); } ACT Null

Lista Circular Idealmente No tiene ni principio ni fin. –Sigue existiendo Cabeza, pero es usada solo para comenzar a recorrer la lista. El Nodo Cola apunta al primer elemento de la lista: Cola–>siguiente==cabeza. –Aunque esto puede variar pues no tiene primer elemento de la lista Las Operaciones posibles son las mismas que en las otras listas. Info Ptro Info Ptro Info Ptro CAB

Ejercicios Complementarios 1.Con Array, crear una lista doblemente enlazada que no tenga espacios vacíos intermedios. Además, implementar las operaciones básicas: Crear, Insertar, Borrar, Modificar. 2.Especificar e implementar un TAD string que permita manipular cadenas de caracteres. –Especifique al menos 10 operaciones. –Implemente al menos 4. Entre ellas, comprobar si una determinada palabra es Palíndromo (la lectura directa o inversa son iguales. Ej: alila)