LISTAS ENLAZADAS FUNDAMENTOS TEORICOS Una lista enlazada es una colección o secuencia de elementos dispuestos uno detrás de otro, en la que cada elemento se conecta al siguiente elemento por un «enlace» o «puntero». La idea básica consiste en construir una lista cuyos elementos llamados nodos se componen de dos partes o campos: la primera parte o campo contiene la información y es, por consiguiente, un valor de un tipo genérico (denominado Dato, TipoElemento, Znfo, etc.) y la segunda parte o campo es un puntero (denominado enlace o sgte) que apunta al siguiente elemento de la lista. CLASIFICACIÓN DE LAS LISTAS ENLAZADAS Las listas se pueden dividir en cuatro categorías : Listas simplemente enlazadas. Cada nodo (elemento) contiene un único enlace que conecta ese nodo al nodo siguiente o nodo sucesor. La lista es eficiente en recorridos directos ((<adelante»). Listas doblemente enlazadas. Cada nodo contiene dos enlaces, uno a su nodo predecesor y el otro a su nodo sucesor. La lista es eficiente tanto en recorrido directo («adelante») como en recorrido inverso («atrás»). Lista circular simplemente enlazada. Una lista enlazada simplemente en la que el último elemento (cola) se enlaza al primer elemento (cabeza) de tal modo que la lista puede ser recorrida de modo circular («en anillo»). Lista circular dohlenzente enlazada. Una lista doblemente enlazada en la que el último elemento se enlaza al primer elemento y viceversa. Esta lista se puede recorrer de modo circular (en anillo) tanto en dirección directa («adelante») como inversa («atrás»). OPERACIONES EN LISTAS ENLAZADAS Una lista enlazada requiere unos controles para la gestión de los elementos contenidos en ellas. Estos controles se manifiestan en forma de operaciones que tendrán las siguientes funciones: Declaración de los tipos nodo y puntero a nodo. Iniciulización o creación. Insertar elementos en una lista. Eliminar elementos de una lista. Buscar elementos de una lisfa (comprobar la existencia de elementos en una lista). Recorrer una lista enlazada (visitar cada nodo de la lista).
Declaración de un nodo Una lista enlazada se compone de una serie de nodos enlazados mediante punteros. Cada nodo es una combinación de dos partes: un tipo de dato (entero, real, doble, carácter o tipo predefinido) y un enlace (puntero) al siguiente nodo. En C, se puede declarar un nuevo tipo de dato por un nodo mediante las palabras reservadas STRUCT que contiene las dos partes citadas. Struct nodo Struct nodo *enlace; ; Struct nodo *cabecera; cabecera=null; utilizando la instrucción typedef: typedef struct Elemento int dato; struct Elemento *enlace; Nodo; Nodo * cabecera; Cabecera = NULL; Construcción de una lista Un algoritmo para la creación de una lista enlazada entraña los siguientes pasos: Paso 1: Declarar el tipo de dato y el puntero de cabeza o primero. Struct nodo Struct nodo *enlace; ; Struct nodo *primero; primero=null; Paso 2: Asignar memoria para un elemento del tipo definido anteriormente utilizando alguna de las funciones de asignación de memoria (mdiloc ( ), calioc ( ), realioc ( ) ). primero=(struct nodo*)malloc(sizeof(struct nodo)); Paso 3: Crear iterativamente el primer elemento (cabeza) y los elementos sucesivos de una lista enlazada simplemente. Paso 4: Repetir hasta que no haya más entrada para el elemento. Ejemplo: La operación de crear un nodo se puede hacer en una función a la que se pasa el valor del campo dato y del campo siguiente. La función devuelve un puntero al nodo creado: Nodo* Crearnodo(1nt x, Nodo* enlace)
Nodo *p; p = (Nodo*)malloc(sizeof(Nodo)); p->dato = x; p->siquiente = enlace; return p; La llamada a la función Crearnodo ( ) para crear el primer nodo de la lista: Primero = Crearnodo(l1, NULL); Si ahora se desea añadir un nuevo elemento con un valor 6, y situarlo en el primer lugar de la lista se escribe simplemente: Primero = Crearnodo(6,Primero); En el siguiente ejemplo se visualiza el programa en Lenguaje C que ejecuta la operación de crear nodos e ir añadiendo los mismos a la lista: #include<stdio.h> struct nodo Struct nodo *siguiente; ; struct nodo *primero; primero= NULL; struct nodo* Crearnodo(1nt x, struct nodo* enlace) Struct nodo *p; p = (stuct nodo*)malloc(sizeof(struct nodo)); p->dato = x; p->siquiente = enlace; return p; main ( ) primero = Crearnodo(l1, NULL); primero = Crearnodo(6,primero); primero= Crearnodo(4, primero); Insertar un nuevo elemento en la cabeza de una lista Aunque normalmente se insertan nuevos datos al final de una estructura de datos, es más fácil y más eficiente insertar un elemento nuevo en la cabeza de una lista. El proceso de inserción se puede resumir en este algoritmo: void InsertarCabezaLista (struct nodo* cabeza, int entrada) struct nodo *nuevo ;
nuevo = (struct nodo*)malloc(sizeof(struct nodo)); / * asigna nuevo nodo * / nuevo -> dato = entrada; / * pone elemento en nuevo * / nuevo -> siguiente = cabeza; / * enlaza nuevo nodo al frente de la lista*/ cabeza = nuevo; / * mueve puntero cabeza y apunta al nuevo nodo * / La función InsertarCabezaLista actúa también correctamente si se trata el caso de añadir un primer nodo o elemento a una lista vacía. Buscar un Elemento en una Lista Enlazada La función BuscarLista utiliza una variable puntero denominado auxiliar(aux) que va recorriendo la lista nodo a nodo. Mediante un bucle, auxiliar apunta a los nodos de la lista de modo que si se encuentra el nodo buscado, se devuelve un puntero al nodo buscado con la sentencia de retorno (return); en el caso de no encontrarse el nodo buscado la función debe devolver NULL (return NULL) Struct nodo*buscarlista(struct nodo*primero, int x) struct nodo* aux; if primero==null printf ( Lista vacia ); else aux=primero; while (aux!=null) If (aux->dato==x) return (aux); else aux=aux->siguiente; return NULL; Eliminar un Elemento de la Lista Enlazada La operación de eliminar un nodo de una lista enlazada supone enlazar el nodo anterior con el nodo siguiente al que se desea eliminar y liberar la memoria que ocupa. El algoritmo para eliminar un nodo que contiene un dato se puede expresar en estos pasos: void eliminar (struct nodo** cabeza, int entrada) Struct nodo* actual, *anterior; int encontrado = 0; actual = *cabeza; anterior = NULL; while ((actual!=null) && (encontrado==0)) / * Bucle de búsqueda * / encontrado = (actual->dato = = entrada); if (encontrado==0) anterior = actual; actual = actual -> siguiente;
if (actual!= NULL) / * Enlace de nodo anterior con siguiente * / / * Se distingue entre que el nodo sea el cabecera o del resto de la lista * / if (actual == cabeza) cabeza = actual->siguiente; Else anterior -> siguiente = actual ->siguiente free(actua1); Mostrar los Elementos de una Lista Enlazada La operación de recorrer e imprimir los elementos de una lista se resume en l el siguiente algoritmo: Void mostrarlista (struct nodo*primero) struct nodo*aux=primero; While (aux!= NULL) printf ( %i, aux->dato); aux=aux->siguiente;