LISTAS “OPERACIONES BÁSICAS”

ü INSERTAR ELEMENTOS EN UNA LISTA VACÍA:

El proceso es muy simple, bastará con que:

1.    nodo->siguiente apunte a NULL.

2.    Lista apunte a nodo.

                                                                                   

ü INSERTAR UN ELEMENTO EN LA PRIMERA POSICIÓN DE UNA LISTA:

El proceso sigue siendo muy sencillo: 

1.    Hacemos que nodo->siguiente apunte a Lista.

2.    Hacemos que Lista apunte a nodo.

ü INSERTAR UN ELEMENTO EN LA ÚLTIMA POSICIÓN DE UNA LISTA:

1.    Necesitamos un puntero que señale al último elemento de la lista. La manera de conseguirlo es empezar por el primero y avanzar hasta que el nodo que tenga como siguiente el valor NULL.

2.    Hacer que nodo->siguiente sea NULL.

3.      Hacer que ultimo->siguiente sea nodo.

ü INSERTAR UN ELEMENTO A CONTINUACIÓN DE UN NODO CUALQUIERA DE UNA LISTA:

El proceso a seguir será:

1.    Hacer que nodo->siguiente señale a anterior->siguiente.

2.    Hacer que anterior->siguiente señale a nodo.

ü LOCALIZAR ELEMENTOS EN UNA LISTA ABIERTA:

1.    Asignamos al puntero índice el valor de Lista.

2.    Abriremos un bucle que al menos debe tener una condición, que el índice no sea NULL.

3.    Dentro del bucle asignaremos al índice el valor del nodo siguiente al índice actual.

Por ejemplo, para mostrar todos los valores de los nodos de una lista, podemos usar el siguiente bucle en C:

typedef struct _nodo {
int dato;
struct _nodo *siguiente;
struct _nodo *anterior;
} tipoNodo;

typedef tipoNodo *pNodo;
typedef tipoNodo *Lista;
...
pNodo = indice;
...
indice = Lista;
while(indice->anterior) indice = indice->anterior;
while(indice) {
printf("%d\n", indice->dato);
indice = indice->siguiente;
}

ü ELIMINAR EL PRIMER NODO DE UNA LISTA ABIERTA:

1.  Hacemos que nodo apunte al primer elemento de la lista, es decir a Lista.

2.  Asignamos a Lista la dirección del segundo nodo de la lista: Lista->siguiente.

3.  Liberamos la memoria asignada al primer nodo, el que queremos eliminar.

           

ü ELIMINAR UN NODO CUALQUIERA DE UNA LISTA ABIERTA

El proceso es parecido al del caso anterior:

1.    Hacemos que nodo apunte al nodo que queremos borrar.

2.    Ahora, asignamos como nodo siguiente del nodo anterior, el siguiente al que queremos eliminar: anterior->siguiente = nodo->siguiente.

3.    Eliminamos la memoria asociada al nodo que queremos eliminar.

ü MOVERSE A TRAVÉS DE UNA LISTA ABIERTA

Sólo hay un modo de moverse a través de una lista abierta, hacia delante.

Primer elemento de una lista:

El primer elemento es el más accesible, ya que es a ese a que apunta el puntero que

define la lista. 

1. Para obtener un puntero al primer elemento bastará con copiar el puntero Lista.

Elemento siguiente a uno cualquiera:

Supongamos que tenemos un puntero nodo que señala a un elemento de una lista. Para obtener un puntero al siguiente bastará con asignarle el campo "siguiente" del nodo, nodo^. Siguiente.

Elemento anterior a uno cualquiera:

Ya hemos dicho que no es posible retroceder en una lista, de modo que para obtener un puntero al nodo anterior a uno dado tendremos que partir del primero, e ir avanzando hasta que el nodo siguiente sea precisamente nuestro nodo, teniendo un puntero auxilia para contener el anterior.

Nodo = Primero

MIENTRAS no sea el nodo buscado HACER

 Auxiliar = Nodo

 Nodo =  Nodo^.siguiente

FIN_MIENTRAS

Auxiliar apuntara al nodo anterior al buscado

Ultimo elemento de una lista:

Para obtener un puntero al último elemento de una lista se parte del primer nodo y se avanza hasta que el nodo apunte a NULO, el auxiliar apuntara al último. También se

puede preguntar anticipadamente por el valor NULO evitándose de este modo el puntero auxiliar.

Suponiendo la lista no vacía

Nodo = Primero;

MIENTRAS Nodo^.siguiente <> NULO HACER

 Nodo _ Nodo^.siguiente

FIN_MIENTRAS

En este caso Nodo, al final del ciclo apunta el último nodo de la estructura

Como determinar si  una lista está vacía:

Basta con comparar el puntero Lista con NULL si Lista vale NULO la lista está vacía.

ü BORRAR UNA LISTA COMPLETA

El algoritmo genérico para borrar una lista completa consiste simplemente en borrar el primer elemento sucesivamente mientras la lista no esté vacía.

Para liberar todo el espacio ocupado por una lista es necesario liberar celda por celda.

procedure borrar_lista(l: lista);

var

   p: lista;

begin

   while l <> nil do

   begin

       p:= l;

       l:= l^.siguiente;

       dispose(p);

   end;

end;