Está en la página 1de 5

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
{
Int dato;
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
{
Int dato;
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
{
Int dato;
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;
}
}