Listas Lenguaje C

INTRODUCCION
El siguiente trabajo ser realizado con la finalidad de referir los conocimientos

bsicos sobre las estructuras de datos adems de indagar cual es la funcin que
estas cumplen dentro del lenguaje c, para empezar se definirn los conceptos de:
Listas abiertas: cada elemento slo dispone de un puntero, que apuntar al
siguiente elemento de la lista o valdr NULL si es el ltimo elemento.
Listas circulares: o listas cerradas, son parecidas a las listas abiertas, pero
el ltimo elemento apunta al primero. De hecho, en las listas circulares no
puede hablarse de "primero" ni de "ltimo". Cualquier nodo puede ser el
nodo de entrada y salida.
Listas doblemente enlazadas: cada elemento dispone de dos punteros, uno
a punta al siguiente elemento y el otro al elemento anterior. Al contrario que
las listas abiertas anteriores, estas listas pueden recorrerse en los dos
sentidos.
Una estructura de datos es una forma de organizar un conjunto de datos
elementales con el objetivo de facilitar la manipulacin de estos datos como un
todo y/o individualmente.
Una estructura de datos define la organizacin y interrelacionamiento de estos, y
un conjunto de operaciones que se pueden realizar sobre l. Las operaciones
bsicas son:
Alta, adicionar un nuevo valor a la estructura.
Baja, borrar un valor de la estructura.
Bsqueda, encontrar un determinado valor en la estructura para se realizar
una operacin con este valor.
Otras operaciones que se pueden realizar son:
Ordenamiento, de los elementos pertenecientes a la estructura.
Apareo, dadas dos estructuras originar una nueva ordenada y que contenga
a las apareadas.
Cada estructura ofrece ventajas y desventajas en relacin a la simplicidad y
eficiencia para la realizacin de cada operacin. De esta forma, la eleccin de la
estructura de datos apropiada para cada problema depende de factores como las
frecuencias y el orden en que se realiza cada operacin sobre los datos.
Las listas enlazadas son muy verstiles. Adems, pueden definirse estructuras
ms complejas a partir de las listas, como por ejemplo arrays de listas, etc. En
algunas ocasiones los grafos se definen como listas de adyacencia. Tambin se
utilizan para las tablas de hash (dispersin) como arrays de listas.
Son eficaces igualmente para disear colas de prioridad, pilas y colas sin
prioridad, y en general cualquier estructura cuyo acceso a sus elementos se
realice de manera secuencial.
Listas
Fundamentos
Las listas son secuencias de elementos, donde estos elementos pueden ser
accedidos, insertados o suprimidos en cualquier posicin de la lista. No existe
restriccin alguna acerca de la localizacin de esas operaciones. Se trata de
estructuras muy flexibles puesto que pueden crecer o acotarse como se quiera.
Matemticamente, una lista es una secuencia de cero o ms elementos de un tipo
determinado (que por lo general denominaremos T). A menudo se representa una
lista como una sucesin de elementos separados por comas:
a(1), a(2), a(3), ... , a(n)
donde a "n" (n >= 0) se le llama longitud de la lista. Al suponer n>=1, se dice que
a(1) es el primer elemento de la lista y a(n) el ltimo elemento. Si n=0, se tiene
una lista vaca.
Una propiedad importante de una lista es que sus elementos pueden estar
ordenados en forma lineal de acuerdo con sus posiciones en la lista. Se dice que
a(i) precede a a(i+1), para i=1,2, .., n-1, y que a(i) sucede a a(i-1), para i=2, 3, .., n.
Tambin se dice que el elemento a(i) est en la posicin i de la lista.
Por lo que se ve, las estructuras pila y cola, no son ms que casos particulares de
la estructura lista generalizada. Al igual que en los casos anteriores, se puede
pensar en representar una lista mediante un array unidimensional, lo que permite
un acceso eficiente a cada uno de los componentes de la estructura, lo que, en
principio, parece proporcionar un esquema adecuado para representar las
operaciones que normalmente se desean realizar sobre la lista: acceder a un
elemento (nodo) arbitrario de la lista, insertar y borrar nodos, etc. Sin embargo, si
bien todas estas consideraciones eran ciertas para las pilas y las colas, cuando se
trata de otro tipo de listas, las operaciones a realizar sobre el array resultan
bastante ms costosas. Por ejemplo, supongamos la siguiente lista:
(Antonio, Bartolom, Carlos, David, Emilio, Germn, Jaime, Jos,
Luis, Manuel)
Si se desea aadir el valor 'Fernando' a esta lista ordenada de nombres, la

operacin se debe realizar en la sexta posicin de la lista, entre los valores 'Emilio'
y 'Germn'. Cuando la lista est representada con un array, dicha insercin
implicar tener que desplazar una posicin hacia la derecha todos los elementos
situados ya en la lista a partir de la posicin seis (Germn,...Manuel), para de esta
forma dejar una posicin libre en el array y poder insertar all el nuevo valor. Por
otro lado, si suponemos que lo que se desea es borrar de la lista el elemento

'Carlos', de nuevo es necesario desplazar elementos para mantener la estructura
secuencial de la lista. En este caso es preciso mover una posicin hacia la
izquierda todos los elementos situados a partir de la cuarta posicin.
Cuando el problema es manipular diferentes listas de tamao variable, la
representacin secuencial prueba ser, de nuevo, poco apropiada. Si se decide
almacenar en distintos arrays cada una de las listas, se tendrn grandes
necesidades de almacenamiento. Si, por el contrario, se toma la decisin de usar
un nico array, se necesitar una cantidad mucho mayor de desplazamientos de
informacin.
Una solucin elegante al problema del desplazamiento de informacin en el
almacenamiento secuencial se logra mediante la utilizacin de representaciones
enlazadas (o ligadas). A diferencia de la representacin secuencial, en la
representacin enlazada los elementos se pueden situar en cualquier posicin de
memoria, y no necesariamente igualmente distantes dentro de ella. Tambin se
puede decir que, si bien en la representacin con arrays el orden de los elementos
es el mismo que el orden en la lista, en una representacin enlazada la secuencia
de orden de la lista no tiene porque coincidir con la secuencia de almacenamiento
en memoria.
Listas enlazadas
Cuando se utilizan representaciones enlazadas para listas, se est rompiendo la
asociacin que exista entre la secuencia lgica establecida en la estructura de
datos y la secuencia fsica que representaba esa lista en un array. Ahora, los
elementos de la lista pueden estar en zonas de memoria no necesariamente
contiguas, lo que tiene como ventaja que cuando se desee insertar un elemento
nuevo, no hay que hacerlo en una posicin concreta de la memoria y que, por lo
tanto, no hay que desplazar elementos. Lo mismo ocurrir con la operacin de
borrado, para eliminar un elemento bastar con aislarlo de la secuencia de orden
que sigue la lista, sin que por ello sea necesario mover ningn elemento.
El almacenamiento no secuencial de la informacin implica que para acceder a los
nodos de la lista en el orden correcto, es necesario almacenar junto a la
informacin propia de cada elemento la localizacin o direccin del siguiente
elemento de la lista, Por ejemplo, supongamos que la anterior lista ordenada de
nombres se almacena de forma no secuencial en la memoria, entonces su
esquema de almacenamiento sera anlogo al mostrado por la siguiente figura,
donde se asocia la estructura de la memoria con la de un array unidimensional.
1
2
3
4
5
6
7
8
9
...
----------
Antonio
Carlos
David
4
7
Emilio
15
Bartolom
...
3
...
Cada elemento de la lista contiene un campo informacin (nombre) ms otro

campo que indica en qu posicin de memoria se encuentra el siguiente elemento
de la lista. As, por ejemplo, el primer elemento de la lista (Antonio) reside en este
caso en la posicin 1, el segundo (Bartolom) en la 9, el tercero (Carlos) en la 3, y
as sucesivamente.
En un lenguaje de programacin, para almacenar la informacin sobre direcciones
de variables se dispone habitualmente del tipo de datos puntero. Entonces,
asociado a la representacin de la informacin de cada nodo hay que aadir un
campo de tipo puntero que permita ir enlazando correctamente todos los nodos de
la lista.
Esto quiere decir que un elemento de la lista tendr ms de un campo de
informacin, como mnimo dos, donde uno (o varios) de ellos representan
informacin que se desea almacenar en la estructura (la verdaderamente
relevante para el problema concreto) y otro(s) permite enlazar cada nodo de la
lista con otro del mismo tipo. Gracias a la utilizacin de punteros es posible evitar
la relacin explcita con las direcciones de memoria. Se trabaja siempre con
referencias a elementos no con direcciones especficas, ya que cada vez que se
ejecute el programa la localizacin real de cada nodo puede cambiar.
En una representacin enlazada, las estructuras de datos se crean por insercin
de nuevos elementos, en este caso no existe un espacio reservado globalmente
para toda la estructura. Entonces, la insercin de un elemento implica realmente
que el espacio reservado para la estructura aumenta, y que cuando se suprime un
nodo, el espacio reservado disminuye. Por esa razn, este tipo de
representaciones reciben el nombre de estructuras dinmicas, porque su tamao
cambia durante la ejecucin del programa adecundose a las necesidades del
problema.
Veamos con un ejemplo concreto cmo la representacin enlazada de una lista
puede facilitar, por ejemplo, la operacin de insercin. Volvamos a considerar el
primer ejemplo tratado en este tema, una lista ordenada de nombres:
(Antonio, Bartolom, Carlos, David, Emilio,
Germn, Jaime, Jos, Luis, Manuel)
donde se desea insertar el nombre 'Fernando'. Su posicin correcta dentro de la

lista es entre 'Emilio' y 'Germn'. Entonces, para insertar el nuevo elemento es
necesario realizar los siguientes pasos:
(1) Reservar espacio para almacenar un nuevo nodo de la lista, sea su
localizacin x.
(2) Introducir en el campo de informacin del nuevo nodo el valor
'Fernando'.
(3) Hacer que el campo de enlace del nuevo nodo apunte al nodo cuya
informacin es Germn.
(4) Hacer que el campo de enlace del nodo cuya informacin es 'Emilio'
apunte a x.
Lo importante es que ya no es necesario mover elementos para insertar un nuevo
nodo. Se ha solventado la necesidad de mover informacin a expensas de
reservar ms espacio en memoria para cada nodo, solamente para almacenar una
direccin de memoria, lo cual, en general, resulta ms conveniente.
Por lo tanto, para hacer posible la representacin enlazada de una estructura de
datos es necesario poseer:
-Un mecanismo para definir la estructura de un nodo.

-Un mtodo para crear nodos cuando se necesiten.
-Un mtodo para liberar el espacio de un nodo cuando ya no sea necesario.
Una lista enlazada o encadenada es una coleccin de elementos nodos, en

donde cada uno contiene datos y un enlace o liga.
Un nodo es una secuencia de caracteres en memoria dividida en campos (de
cualquier tipo). Un nodo siempre contiene la direccin de memoria del siguiente
nodo de informacin si este existe.
Un apuntador es la direccin de memoria de un nodo
La figura siguiente muestra la estructura de un nodo:
El campo liga, que es de tipo puntero, es el que se usa para establecer la liga con
el siguiente nodo de la lista. Si el nodo fuera el ltimo, este campo recibe como
valor NIL (vaco).
A continuacin se muestra el esquema de una lista :
Una manera de clasificarlas es por la forma de acceder al siguiente

elemento:
Lista Densa: La propia estructura determina cul es el siguiente elemento de la
lista.
Se caracterizan porque los elementos siguen una secuencia fsica. Sabemos
cuales es el siguiente elemento porque para acceder a l hemos tenido que pasar
por todos los anteriores.
La localizacin de un elemento cualquiera ser:
El primero si es el primer elemento de la lista.
N-esimo si para llegar a el hemos pasado por N-1 elementos.
Siguen una estructura fsica secuencial luego se pueden implementar utilizando
ficheros, ARRAYS y punteros.
Lista Enlazada: La posicin del siguiente elemento de la estructura la determina
el elemento actual. Es necesario almacenar al menos la posicin de memoria del
primer elemento. Adems es dinmica, es decir, su tamao cambia durante la
ejecucin del programa.
Son aquellas en las que cada elemento que los compone contiene la informacin
necesaria para acceder al elemento siguiente.
La localizacin de un elemento cualquiera ser:
Un elemento de la lista tendr la direccin K si K es el primero y K es conocido
(direccin de inicio).
Estar en la direccin J si J est contenida en el elemento anterior.
Las operaciones que podemos realizar sobre una lista enlazada son las
siguientes:
Recorrido. Esta operacin consiste en visitar cada uno de los nodos que
forman la lista . Para recorrer todos los nodos de la lista, se comienza con
el primero, se toma el valor del campo liga para avanzar al segundo nodo,
el campo liga de este nodo nos dar la direccin del tercer nodo, y as
sucesivamente.
Insercin. Esta operacin consiste en agregar un nuevo nodo a la lista.
Para esta operacin se pueden considerar tres casos:
Insertar un nodo al inicio.

Insertar un nodo antes o despus de cierto nodo.
Insertar un nodo al final.
Borrado. La operacin de borrado consiste en quitar un nodo de la lista,
redefiniendo las ligas que correspondan. Se pueden presentar cuatro
casos:
o Eliminar el primer nodo.
o Eliminar el ltimo nodo.
o Eliminar un nodo con cierta informacin.
o Eliminar el nodo anterior o posterior al nodo cierta con informacin.
Bsqueda. Esta operacin consiste en visitar cada uno de los nodos,
tomando al campo liga como puntero al siguiente nodo a visitar.
o
o
o
Listas abiertas
1.1 Definicin:
La forma ms simple de estructura dinmica es la lista abierta. En esta forma los
nodos se organizan de modo que cada uno apunta al siguiente, y el ltimo no
apunta a nada, es decir, el puntero del nodo siguiente vale NULL.
En las listas abiertas existe un nodo especial: el primero. Normalmente diremos
que nuestra lista es un puntero a ese primer nodo y llamaremos a ese nodo la
cabeza de la lista. Eso es porque mediante ese nico puntero podemos acceder a
toda la lista.
Cuando el puntero que usamos para acceder a la lista vale NULL, diremos que la
lista est vaca.
El nodo tpico para construir listas tiene esta forma:
struct nodo {
int dato;
struct nodo *siguiente;
};
En el ejemplo, cada elemento de la lista slo contiene un dato de tipo entero, pero
en la prctica no hay lmite en cuanto a la complejidad de los datos a almacenar.
1.2 Declaraciones de tipos para manejar listas en C:
Normalmente se definen varios tipos que facilitan el manejo de las listas, en C, la
declaracin de tipos puede tener una forma parecida a esta:
10
typedef struct _nodo {

int dato;
struct _nodo *siguiente;
} tipoNodo;
typedef tipoNodo *pNodo;
typedef tipoNodo *Lista;
tipoNodo es el tipo para declarar nodos, evidentemente.
pNodo es el tipo para declarar punteros a un nodo.
Lista es el tipo para declarar listas, como puede verse, un puntero a un nodo y una
lista son la misma cosa. En realidad, cualquier puntero a un nodo es una lista,
cuyo primer elemento es el nodo apuntado.
Es muy importante que nuestro programa nunca pierda el valor del puntero al
primer elemento, ya que si no existe ninguna copia de ese valor, y se pierde, ser
imposible acceder al nodo y no podremos liberar el espacio de memoria que
ocupa.
1.3 Operaciones bsicas con listas:
Con las listas tendremos un pequeo repertorio de operaciones bsicas que se
pueden realizar:
Aadir o insertar elementos.

Buscar o localizar elementos.
Borrar elementos.
Moverse a travs de una lista, anterior, siguiente, primero.
Cada una de estas operaciones tendr varios casos especiales, por ejemplo, no
ser lo mismo insertar un nodo en una lista vaca, o al principio de una lista no
vaca, o la final, o en una posicin intermedia.
1.4 Insertar elementos en una lista abierta:
Veremos primero los casos sencillos y finalmente construiremos un algoritmo
genrico para la insercin de elementos en una lista.
11
Insertar un elemento en una lista vaca:

Este es, evidentemente, el caso ms sencillo. Partiremos de que ya tenemos el
nodo a insertar y, por supuesto un puntero que apunte a l, adems el puntero a la
lista valdr NULL:
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 posicin de una lista:
Podemos considerar el caso anterior como un caso particular de ste, la nica
diferencia es que en el caso anterior la lista es una lista vaca, pero siempre
podemos, y debemos considerar una lista vaca como una lista.
De nuevo partiremos de un nodo a insertar, con un puntero que apunte a l, y de
una lista, en este caso no vaca:
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 posicin de una lista:

Este es otro caso especial. Para este caso partiremos de una lista no vaca:
12
El proceso en este caso tampoco es excesivamente complicado:

1. Necesitamos un puntero que seale 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 continuacin de un nodo cualquiera de una lista:

De nuevo podemos considerar el caso anterior como un caso particular de este.
Ahora el nodo "anterior" ser aquel a continuacin del cual insertaremos el nuevo
nodo:
Suponemos que ya disponemos del nuevo nodo a insertar, apuntado por nodo, y
un puntero al nodo a continuacin del que lo insertaremos.
El proceso a seguir ser:
1. Hacer que nodo->siguiente seale a anterior->siguiente.
2. Hacer que anterior->siguiente seale a nodo.
1.5 Localizar elementos en una lista abierta:

Muy a menudo necesitaremos recorrer una lista, ya sea buscando un valor
particular o un nodo concreto. Las listas abiertas slo pueden recorrerse en un
13
sentido, ya que cada nodo apunta al siguiente, pero no se puede obtener, por
ejemplo, un puntero al nodo anterior desde un nodo cualquiera si no se empieza
desde el principio.
Para recorrer una lista procederemos siempre del mismo modo, usaremos un
puntero auxiliar como ndice:
1. Asignamos al puntero ndice el valor de Lista.
2. Abriremos un bucle que al menos debe tener una condicin, 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 siguente bucle en C:

int dato;
} tipoNodo;
...
pNodo indice;
...
indice = Lista;
while(indice) {
printf("%d\n", indice->dato);
indice = indice->siguiente;
}
...
Supongamos que slo queremos mostrar los valores hasta que encontremos uno
que sea mayor que 100, podemos sustituir el bucle por:
...
indice = Lista;
while(indice && indice->dato <= 100) {
14
}
...
Si analizamos la condicin del bucle, tal vez encontremos un posible error: Qu
pasara si ningn valor es mayor que 100, y alcancemos el final de la lista?. Podra
pensarse que cuando indice sea NULL, si intentamos acceder a indice->dato se
producir un error.
En general eso ser cierto, no puede accederse a punteros nulos. Pero en este
caso, ese acceso est dentro de una condicin y forma parte de una expresin
"and". Recordemos que cuando se evala una expresin "and", se comienza por
la izquierda, y la evaluacin se abandona cuando una de las expresiones resulta
falsa, de modo que la expresin "indice->dato <= 100" nunca se evaluar si indice
es NULL.
Si hubiramos escrito la condicin al revs, el programa nunca funcionara bien.
Esto es algo muy importante cuando se trabaja con punteros.
1.6 Eliminar elementos en una lista abierta:
De nuevo podemos encontrarnos con varios casos, segn la posicin del nodo a
eliminar.
Eliminar el primer nodo de una lista abierta:
Es el caso ms simple. Partiremos de una lista con uno o ms nodos, y usaremos
un puntero auxiliar, nodo:
1. Hacemos que nodo apunte al primer elemento de la lista, es decir a Lista.

2. Asignamos a Lista la direccin del segundo nodo de la lista: Lista>siguiente.
3. Liberamos la memoria asignada al primer nodo, el que queremos eliminar.
Si no guardamos el puntero al primer nodo antes de actualizar Lista, despus nos
resultara imposible liberar la memoria que ocupa. Si liberamos la memoria antes
de actualizar Lista, perderemos el puntero al segundo nodo.
15
Si la lista slo tiene un nodo, el proceso es tambin vlido, ya que el valor de

Lista->siguiente es NULL, y despus de eliminar el primer nodo la lista quedar
vaca, y el valor de Lista ser NULL.
De hecho, el proceso que se suele usar para borrar listas completas es eliminar el
primer nodo hasta que la lista est vaca.
Eliminar un nodo cualquiera de una lista abierta:
En todos los dems casos, eliminar un nodo se puede hacer siempre del mismo
modo. Supongamos que tenemos una lista con al menos dos elementos, y un
puntero al nodo anterior al que queremos eliminar. Y un puntero auxiliar nodo.
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.
Si el nodo a eliminar es el ltimo, es procedimiento es igualmente vlido, ya que

anterior pasar a ser el ltimo, y anterior->siguiente valdr NULL.
1.7 Moverse a travs de una lista abierta:
Slo hay un modo de moverse a travs de una lista abierta, hacia delante.
An as, a veces necesitaremos acceder a determinados elementos de una lista
abierta. Veremos ahora como acceder a los ms corrientes: el primero, el ltimo, el
siguiente y el anterior.
16
Primer elemento de una lista:

El primer elemento es el ms accesible, ya que es a ese a que apunta el puntero
que define la lista. 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 seala 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.
Ultimo elemento de una lista:
Para obtener un puntero al ltimo elemento de una lista partiremos de un nodo
cualquiera, por ejemplo el primero, y avanzaremos hasta que su nodo siguiente
sea NULL.
Saber si una lista est vaca:
Basta con comparar el puntero Lista con NULL, si Lista vale NULL la lista est
vaca.
1.8 Borrar una lista completa:
El algoritmo genrico para borrar una lista completa consiste simplemente en
borrar el primer elemento sucesivamente mientras la lista no est vaca.
1.9 Ejemplo de lista abierta ordenada en C:
Supongamos que queremos construir una lista para almacenar nmeros enteros,
pero de modo que siempre est ordenada de menor a mayor. Para hacer la
prueba aadiremos los valores 20, 10, 40, 30. De este modo tendremos todos los
casos posibles. Al comenzar, el primer elemento se introducir en una lista vaca,
el segundo se insertar en la primera posicin, el tercero en la ltima, y el ltimo
en una posicin intermedia.
Insertar un elemento en una lista vaca es equivalente a insertarlo en la primera
posicin. De modo que no incluiremos una funcin para asignar un elemento en
17
una lista vaca, y haremos que la funcin para insertar en la primera posicin nos
sirva para ese caso tambin.
Algoritmo de insercin:
1. El primer paso es crear un nodo para el dato que vamos a insertar.
2. Si Lista es NULL, o el valor del primer elemento de la lista es mayor que el
del nuevo, insertaremos el nuevo nodo en la primera posicin de la lista.
3. En caso contrario, buscaremos el lugar adecuado para la insercin,
tenemos un puntero "anterior". Lo inicializamos con el valor de Lista, y
avanzaremos mientras anterior->siguiente no sea NULL y el dato que
contiene anterior->siguiente sea menor o igual que el dato que queremos
insertar.
4. Ahora ya tenemos anterior sealando al nodo adecuado, as que
insertamos el nuevo nodo a continuacin de l.
void Insertar(Lista *lista, int v) {

pNodo nuevo, anterior;
/* Crear un nodo nuevo */
nuevo = (pNodo)malloc(sizeof(tipoNodo));
nuevo->valor = v;
/* Si la lista est vaca */
if(ListaVacia(*lista) || (*lista)->valor > v) {
/* Aadimos la lista a continuacin del nuevo
nodo */
nuevo->siguiente = *lista;
/* Ahora, el comienzo de nuestra lista es en
nuevo nodo */
*lista = nuevo;
}
else {
/* Buscar el nodo de valor menor a v */
anterior = *lista;
/* Avanzamos hasta el ltimo elemento o hasta
que el siguiente tenga
un valor mayor que v */
while(anterior->siguiente && anterior>siguiente->valor <= v)
anterior = anterior->siguiente;
18
/* Insertamos el nuevo nodo despus del nodo

anterior */
nuevo->siguiente = anterior->siguiente;
anterior->siguiente = nuevo;
}
}
Algoritmo para borrar un elemento:
Despus probaremos la funcin para buscar y borrar, borraremos los elementos
10, 15, 45, 30 y 40, as probaremos los casos de borrar el primero, el ltimo y un
caso intermedio o dos nodos que no existan.
Recordemos que para eliminar un nodo necesitamos disponer de un puntero al
nodo anterior.
1. Lo primero ser localizar el nodo a eliminar, si es que existe. Pero sin
perder el puntero al nodo anterior. Partiremos del nodo primero, y del valor
NULL para anterior. Y avanzaremos mientras nodo no sea NULL o mientras
que el valor almacenado en nodo sea menor que el que buscamos.
2. Ahora pueden darse tres casos:
3. Que el nodo sea NULL, esto indica que todos los valores almacenados en
la lista son menores que el que buscamos y el nodo que buscamos no
existe. Retornaremos sin borrar nada.
4. Que el valor almacenado en nodo sea mayor que el que buscamos, en ese
caso tambin retornaremos sin borrar nada, ya que esto indica que el nodo
que buscamos no existe.
5. Que el valor almacenado en el nodo sea igual al que buscamos.
6. De nuevo existen dos casos:
7. Que anterior sea NULL. Esto indicara que el nodo que queremos borrar es
el primero, as que modificamos el valor de Lista para que apunte al nodo
siguiente al que queremos borrar.
8. Que anterior no sea NULL, el nodo no es el primero, as que asignamos a
anterior->siguiente la direccin de nodo->siguiente.
9. Despus de 7 u 8, liberamos la memoria de nodo.
void Borrar(Lista *lista, int v) {

pNodo anterior, nodo;
nodo = *lista;
anterior = NULL;
19
while(nodo && nodo->valor < v) {

anterior = nodo;
nodo = nodo->siguiente;
}
if(!nodo || nodo->valor != v) return;
else { /* Borrar el nodo */
if(!anterior) /* Primer elemento */
*lista = nodo->siguiente;
else /* un elemento cualquiera */
anterior->siguiente = nodo->siguiente;
free(nodo);
}
Cdigo del ejemplo completo:
#include <stdlib.h>
#include <stdio.h>
int valor;
} tipoNodo;
/* Funciones con listas: */
void Insertar(Lista *l, int v);
void Borrar(Lista *l, int v);
int ListaVacia(Lista l);
void BorrarLista(Lista *);
void MostrarLista(Lista l);
int main() {
Lista lista = NULL;
20
pNodo p;
Insertar(&lista,
Insertar(&lista,
Insertar(&lista,
Insertar(&lista,
20);
10);
40);
30);
MostrarLista(lista);
Borrar(&lista,
Borrar(&lista,
Borrar(&lista,
Borrar(&lista,
Borrar(&lista,
10);
15);
45);
30);
40);
BorrarLista(&lista);
getchar();
return 0;
}
pNodo nuevo, anterior;
nuevo->valor = v;
/* Si la lista est vaca */
if(ListaVacia(*lista) || (*lista)->valor > v) {
nodo */
nuevo->siguiente = *lista;
/* Ahora, el comienzo de nuestra lista es en
nuevo nodo */
*lista = nuevo;
}
21
else {
/* Buscar el nodo de valor menor a v */
anterior = *lista;
while(anterior->siguiente && anterior>siguiente->valor <= v)
anterior = anterior->siguiente;
anterior */
nuevo->siguiente = anterior->siguiente;
anterior->siguiente = nuevo;
}
}
pNodo anterior, nodo;
nodo = *lista;
anterior = NULL;
while(nodo && nodo->valor < v) {
anterior = nodo;
}
else { /* Borrar el nodo */
if(!anterior) /* Primer elemento */
else /* un elemento cualquiera */
anterior->siguiente = nodo->siguiente;
free(nodo);
}
}
int ListaVacia(Lista lista) {
return (lista == NULL);
}
22
void BorrarLista(Lista *lista) {

pNodo nodo;
while(*lista) {
nodo = *lista;
free(nodo);
}
void MostrarLista(Lista lista) {

pNodo nodo = lista;
if(ListaVacia(lista)) printf("Lista vaca\n");
else {
while(nodo) {
printf("%d -> ", nodo->valor);
}
printf("\n");
}
}
Listas circulares
2.1 Definicin
Una lista circular es una lista lineal en la que el ltimo nodo a punta al primero.
Las listas circulares evitan excepciones en la operaciones que se realicen sobre
ellas. No existen casos especiales, cada nodo siempre tiene uno anterior y uno
siguiente.
En algunas listas circulares se aade un nodo especial de cabecera, de ese modo
se evita la nica excepcin posible, la de que la lista est vaca.
El nodo tpico es el mismo que para construir listas abiertas:
23
struct nodo {
int dato;
};
2.2 Declaraciones de tipos para manejar listas circulares en C:
Los tipos que definiremos normalmente para manejar listas cerradas son los
mismos que para para manejar listas abiertas:

int dato;
} tipoNodo;
Lista es el tipo para declarar listas, tanto abiertas como circulares. En el caso de
las circulares, apuntar a un nodo cualquiera de la lista.
A pesar de que las listas circulares simplifiquen las operaciones sobre ellas,
tambin introducen algunas complicaciones. Por ejemplo, en un proceso de
bsqueda, no es tan sencillo dar por terminada la bsqueda cuando el elemento
buscado no existe.
Por ese motivo se suele resaltar un nodo en particular, que no tiene por qu ser
siempre el mismo. Cualquier nodo puede cumplir ese propsito, y puede variar
durante la ejecucin del programa.
24
Otra alternativa que se usa a menudo, y que simplifica en cierto modo el uso de
listas circulares es crear un nodo especial de har la funcin de nodo cabecera.
De este modo, la lista nunca estar vaca, y se eliminan casi todos los casos
especiales.
2.3 Operaciones bsicas con listas circulares:
A todos los efectos, las listas circulares son como las listas abiertas en cuanto a
las operaciones que se pueden realizar sobre ellas:

Borrar elementos.
Moverse a travs de la lista, siguiente.
Cada una de estas operaciones podr tener varios casos especiales, por ejemplo,
tendremos que tener en cuenta cuando se inserte un nodo en una lista vaca, o
cuando se elimina el nico nodo de una lista.
2.4 Aadir un elemento:
El nico caso especial a la hora de insertar nodos en listas circulares es cuando la
lista est vaca.
Aadir elemento en una lista circular vaca:
Partiremos de que ya tenemos el nodo a insertar y, por supuesto un puntero que
apunte a l, adems el puntero que define la lista, que valdr NULL:

1. lista apunta a nodo.
2. lista->siguiente apunte a nodo.
Aadir elemento en una lista circular no vaca:
25
De nuevo partiremos de un nodo a insertar, con un puntero que apunte a l, y de

una lista, en este caso, el puntero no ser nulo:

1. Hacemos que nodo->siguiente apunte a lista->siguiente.
2. Despus que lista->siguiente apunte a nodo.
Aadir elemento en una lista circular, caso general:

Para generalizar los dos casos anteriores, slo necesitamos aadir una operacin:
1. Si lista est vaca hacemos que lista apunte a nodo.
2. Si lista no est vaca, hacemos que nodo->siguiente apunte a lista>siguiente.
2.5 Buscar o localizar un elemento de una lista circular:
A la hora de buscar elementos en una lista circular slo hay que tener una
precaucin, es necesario almacenar el puntero del nodo en que se empez la
bsqueda, para poder detectar el caso en que no exista el valor que se busca. Por
lo dems, la bsqueda es igual que en el caso de las listas abiertas, salvo que
podemos empezar en cualquier punto de la lista.
2.6 Eliminar un elemento de una lista circular:
Para sta operacin podemos encontrar tres casos diferentes:
1. Eliminar un nodo cualquiera, que no sea el apuntado por lista.
2. Eliminar el nodo apuntado por lista, y que no sea el nico nodo.
3. Eliminar el nico nodo de la lista.
26
En el primer caso necesitamos localizar el nodo anterior al que queremos borrar.

Como el principio de la lista puede ser cualquier nodo, haremos que sea
precisamente lista quien apunte al nodo anterior al que queremos eliminar.
Esto elimina la excepcin del segundo caso, ya que lista nunca ser el nodo a
eliminar, salvo que sea el nico nodo de la lista.
Una vez localizado el nodo anterior y apuntado por lista, hacemos que lista>siguiente apunte a nodo->siguiente. Y a continuacin borramos nodo.
En el caso de que slo exista un nodo, ser imposible localizar el nodo anterior,
as que simplemente eliminaremos el nodo, y haremos que lista valga NULL.
Eliminar un nodo en una lista circular con ms de un elemento:
Consideraremos los dos primeros casos como uno slo.
1. El primer paso es conseguir que lista apunte al nodo anterior al que

queremos eliminar. Esto se consigue haciendo que lista valga lista>siguiente mientras lista->siguiente sea distinto de nodo.
2. Hacemos que lista->siguiente apunte a nodo->siguiente.
3. Eliminamos el nodo.
Eliminar el nico nodo en una lista circular:

Este caso es mucho ms sencillo. Si lista es el nico nodo de una lista circular:
1. Borramos el nodo apuntado por lista.
2. Hacemos que lista valga NULL.
Otro algoritmo para borrar nodos:
Existe un modo alternativo de eliminar un nodo en una lista circular con ms de un
nodo.
27
Supongamos que queremos eliminar un nodo apuntado por nodo:
1.
2.
3.
4.
Copiamos el contenido del nodo->siguiente sobre el contenido de nodo.

Hhacemos que nodo->siguiente apunte a nodo->siguiente->siguiente.
Eliminamos nodo->siguiente.
Si lista es el nodo->siguiente, hacemos lista = nodo.
Este mtodo tambin funciona con listas circulares de un slo elemento, salvo que
el nodo a borrar es el nico nodo que existe, y hay que hacer que lista apunte a
NULL.
2.7 Ejemplo de lista circular en C:
Construiremos una lista cerrada para almacenar nmeros enteros. Haremos
pruebas insertando varios valores, buscndolos y eliminndolos alternativamente
para comprobar el resultado.
Algoritmo de la funcin "Insertar":
1. Si lista est vaca hacemos que lista apunte a nodo.
2. Si lista no est vaca, hacemos que nodo->siguiente apunte a lista>siguiente.

pNodo nodo;
// Creamos un nodo para el nuvo valor a insertar
nodo = (pNodo)malloc(sizeof(tipoNodo));
nodo->valor = v;
28
// Si la lista est vaca, la lista ser el nuevo

nodo
// Si no lo est, insertamos el nuevo nodo a
continuacin del apuntado
// por lista
if(*lista == NULL) *lista = nodo;
else nodo->siguiente = (*lista)->siguiente;
// En cualquier caso, cerramos la lista circular
(*lista)->siguiente = nodo;
}
Algoritmo de la funcin "Borrar":
1. Tiene la lista un nico nodo?
2. SI:
1. Borrar el nodo lista.
2. Hacer lista = NULL.
3. NO:
1. Hacemos lista->siguiente = nodo->siguiente.
2. Borramos nodo.

pNodo nodo;
nodo = *lista;
// Hacer que lista apunte al nodo anterior al de
valor v
do {
if((*lista)->siguiente->valor != v) *lista =
(*lista)->siguiente;
} while((*lista)->siguiente->valor != v && *lista
!= nodo);
// Si existe un nodo con el valor v:
if((*lista)->siguiente->valor == v) {
// Y si la lista slo tiene un nodo
if(*lista == (*lista)->siguiente) {
// Borrar toda la lista
free(*lista);
*lista = NULL;
29
}
else {
// Si la lista tiene ms de un nodo, borrar
el nodo de valor v
nodo = (*lista)->siguiente;
(*lista)->siguiente = nodo->siguiente;
free(nodo);
}
}
}
Tan slo nos queda escribir una pequea prueba para verificar el funcionamiento:
#include <stdio.h>
int valor;
} tipoNodo;
// Funciones con listas:
void MostrarLista(Lista l);
int main() {
Lista lista = NULL;
pNodo p;
Insertar(&lista, 10);
30
Borrar(&lista, 30);
Borrar(&lista, 50);
getchar();
return 0;
}
pNodo nodo;
// Creamos un nodo para el nuvo valor a insertar
nodo = (pNodo)malloc(sizeof(tipoNodo));
nodo->valor = v;
// Si la lista est vaca, la lista ser el nuevo
nodo
// Si no lo est, insertamos el nuevo nodo a
continuacin del apuntado
// por lista
if(*lista == NULL) *lista = nodo;
else nodo->siguiente = (*lista)->siguiente;
// En cualquier caso, cerramos la lista circular
(*lista)->siguiente = nodo;
}
pNodo nodo;
nodo = *lista;
31
// Hacer que lista apunte al nodo anterior al de

valor v
do {
if((*lista)->siguiente->valor != v) *lista =
(*lista)->siguiente;
} while((*lista)->siguiente->valor != v && *lista
!= nodo);
// Si existe un nodo con el valor v:
if((*lista)->siguiente->valor == v) {
// Y si la lista slo tiene un nodo
if(*lista == (*lista)->siguiente) {
// Borrar toda la lista
free(*lista);
*lista = NULL;
}
else {
// Si la lista tiene ms de un nodo, borrar
el nodo de valor v
free(nodo);
}
}
}
pNodo nodo;
// Mientras la lista tenga ms de un nodo
while((*lista)->siguiente != *lista) {
// Borrar el nodo siguiente al apuntado por
lista
free(nodo);
}
// Y borrar el ltimo nodo
free(*lista);
*lista = NULL;
32
}
void MostrarLista(Lista lista) {
pNodo nodo = lista;
do {
} while(nodo != lista);
printf("\n");
Listas doblemente enlazadas

3.1 Definicin
Una lista doblemente enlazada es una lista lineal en la que cada nodo tiene dos
enlaces, uno al nodo siguiente, y otro al anterior.
Las listas doblemente enlazadas no necesitan un nodo especial para acceder a
ellas, pueden recorrerse en ambos sentidos a partir de cualquier nodo, esto es
porque a partir de cualquier nodo, siempre es posible alcanzar cualquier nodo de
la lista, hasta que se llega a uno de los extremos.
El nodo tpico es el mismo que para construir las listas que hemos visto, salvo que
tienen otro puntero al nodo anterior:
struct nodo {
int dato;
struct nodo *anterior;
};
3.2 Declaraciones de tipos para manejar listas doblemente enlazadas en C:
Para C, y basndonos en la declaracin de nodo que hemos visto ms arriba,
trabajaremos con los siguientes tipos:
33

int dato;
struct _nodo *anterior;
} tipoNodo;
Lista es el tipo para declarar listas abiertas doblemente enlazadas. Tambin es
posible, y potencialmente til, crear listas doblemente enlazadas y circulares.
El movimiento a travs de listas doblemente enlazadas es ms sencillo, y como

veremos las operaciones de bsqueda, insercin y borrado, tambin tienen ms
ventajas.
3.3 Operaciones bsicas con listas doblemente enlazadas:
De nuevo tenemos el mismo repertorio de operaciones sobre este tipo listas:

Borrar elementos.
Moverse a travs de la lista, siguiente y anterior.
3.4 Aadir un elemento:

Nos encontramos ahora ante un tipo de estructura algo diferente de las que hemos
estado viendo, as que entraremos en ms detalles.
Vamos a intentar ver todos los casos posibles de insercin de elementos en listas
doblemente enlazadas.
34
Aadir elemento en una lista doblemente enlazada vaca:

Partiremos de que ya tenemos el nodo a insertar y, por supuesto un puntero que
apunte a l, adems el puntero que define la lista, que valdr NULL:

1. lista apunta a nodo.
2. lista->siguiente y lista->anterior apunten a null.
Insertar un elemento en la primera posicin de la lista:

Partimos de una lista no vaca. Para simplificar, consideraremos que lista apunta al
primer elemento de la lista doblemente enlazada:
El proceso es el siguiente:
1. nodo->siguiente debe apuntar a Lista.
2. nodo->anterior apuntar a Lista->anterior.
3. Lista->anterior debe apuntar a nodo.
35
Recuerda que Lista no tiene por qu apuntar a ningn miembro concreto de una
lista doblemente enlazada, cualquier miembro es igualmente vlido como
referencia.
Insertar un elemento en la ltima posicin de la lista:
Igual que en el caso anterior, partiremos de una lista no vaca, y de nuevo para
simplificar, que Lista est apuntando al ltimo elemento de la lista:
El proceso es el siguiente:
1. nodo->siguiente debe apuntar a Lista->siguiente (NULL).
2. Lista->siguiente debe apuntar a nodo.
3. nodo->anterior apuntar a Lista.
Insertar un elemento a continuacin de un nodo cualquiera de una lista:

Bien, este caso es ms genrico, ahora partimos de una lista no vaca, e
insertaremos un nodo a continuacin de uno nodo cualquiera que no sea el ltimo
de la lista:

1. Hacemos que nodo->siguiente apunte a lista->siguiente.
36
2. Hacemos que Lista->siguiente apunte a nodo.

3. Hacemos que nodo->anterior apunte a lista.
4. Hacemos que nodo->siguiente->anterior apunte a nodo.
Lo que hemos hecho es trabajar como si tuviramos dos listas enlazadas, los dos
primeros pasos equivalen a lo que hacamos para insertar elementos en una lista
abierta corriente.
Los dos siguientes pasos hacen lo mismo con la lista que enlaza los nodos en
sentido contrario.
El paso 4 es el ms oscuro, quizs requiera alguna explicacin.
Supongamos que disponemos de un puntero auxiliar, "p" y que antes de empezar
a insertar nodo, hacemos que apunte al nodo que quedar a continuacin de nodo
despus de insertarlo, es decir p = Lista->siguiente.
Ahora empezamos el proceso de insercin, ejecutamos los pasos 1, 2 y 3. El
cuarto sera slo hacer que p->anterior apunte a nodo. Pero nodo->siguiente ya
apunta a p, as que en realidad no necesitamos el puntero auxiliar, bastar con
hacer que nodo->siguiente->anterior apunte a nodo.
Aadir elemento en una lista doblemente enlazada, caso general:
Para generalizar todos los casos anteriores, slo necesitamos aadir una
operacin:
1. Si lista est vaca hacemos que Lista apunte a nodo. Y nodo->anterior y
nodo->siguiente a NULL.
2. Si lista no est vaca, hacemos que nodo->siguiente apunte a Lista>siguiente.
3. Despus que Lista->siguiente apunte a nodo.
4. Hacemos que nodo->anterior apunte a Lista.
5. Si nodo->siguiente no es NULL, entonces hacemos que nodo->siguiente>anterior apunte a nodo.
El paso 1 es equivalente a insertar un nodo en una lista vaca.
37
Los pasos 2 y 3 equivalen a la insercin en una lista enlazada corriente.

Los pasos 4, 5 equivalen a insertar en una lista que recorre los nodos en sentido
contrario.
Existen ms casos, las listas doblemente enlazadas son mucho ms verstiles,
pero todos los casos pueden reducirse a uno de los que hemos explicado aqu.
3.5 Buscar o localizar un elemento de una lista doblemente enlazada:
En muchos aspectos, una lista doblemente enlazada se comporta como dos listas
abiertas que comparten los datos. En ese sentido, todo lo dicho en el captulo
sobre la localizacin de elementos en listas abiertas se puede aplicar a listas
doblemente enlazadas.
Pero adems tenemos la ventaja de que podemos avanzar y retroceder desde
cualquier nodo, sin necesidad de volver a uno de los extremos de la lista.
Por supuesto, se pueden hacer listas doblemente enlazadas no ordenadas,
existen cientos de problemas que pueden requerir de este tipo de estructuras.
Pero parece que la aplicacin ms sencilla de listas doblemente enlazadas es
hacer arrays dinmicos ordenados, donde buscar un elemento concreto a partir de
cualquier otro es ms sencillo que en una lista abierta corriente.
Pero de todos modos veamos algn ejemplo sencillo.
Para recorrer una lista procederemos de un modo parecido al que usbamos con
las listas abiertas, ahora no necesitamos un puntero auxiliar, pero tenemos que
tener en cuenta que Lista no tiene por qu estar en uno de los extremos:
1. Retrocedemos hasta el comienzo de la lista, asignamos a lista el valor de
lista->anterior mientras lista->anterior no sea NULL.
2. Abriremos un bucle que al menos debe tener una condicin, que el ndice
no sea NULL.
3. Dentro del bucle asignaremos a lista el valor del nodo siguiente al actual.
Por ejemplo, para mostrar todos los valores de los nodos de una lista, podemos
usar el siguiente bucle en C:

int dato;
} tipoNodo;
38

...
pNodo = indice;
...
indice = Lista;
while(indice->anterior) indice = indice->anterior;
while(indice) {
}
...
Es importante que no perdamos el nodo Lista, si por error le asignramos un valor
de un puntero a un nodo que no est en la lista, no podramos acceder de nuevo a
ella.
Es por eso que tendremos especial cuidado en no asignar el valor NULL a Lista.
3.6 Eliminar un elemento de una lista doblemente enlazada:
Analizaremos tres casos diferentes:
1.
2.
3.
4.
Eliminar el nico nodo de una lista doblemente enlazada.

Eliminar el primer nodo.
Eliminar el ltimo nodo.
Eliminar un nodo intermedio.
Para los casos que lo permitan consideraremos dos casos: que el nodo a eliminar
es el actualmente apuntado por Lista o que no.
Eliminar el nico nodo en una lista doblemente enlazada:

En este caso, ese nodo ser el apuntado por Lista.
1. Eliminamos el nodo.
39
2. Hacemos que Lista apunte a NULL.
Eliminar el primer nodo de una lista doblemente enlazada:

Tenemos los dos casos posibles, que el nodo a borrar est apuntado por Lista o
que no. Si lo est, simplemente hacemos que Lista sea Lista->siguiente.
1. Si nodo apunta a Lista, hacemos que Lista apunte a Lista->siguiente.

2. Hacemos que nodo->siguiente->anterior apunte a NULL
3. Borramos el nodo apuntado por nodo.
El paso 2 depara el nodo a borrar del resto de la lista, independientemente del

nodo al que apunte Lista.
Eliminar el ltimo nodo de una lista doblemente enlazada:
De nuevo tenemos los dos casos posibles, que el nodo a borrar est apuntado por
Lista o que no. Si lo est, simplemente hacemos que Lista sea Lista->anterior.
1. Si nodo apunta a Lista, hacemos que Lista apunte a Lista->anterior.

2. Hacemos que nodo->anterior->siguiente apunte a NULL
40
El paso 2 depara el nodo a borrar del resto de la lista, independientemente del

nodo al que apunte Lista.
Eliminar un nodo intermedio de una lista doblemente enlazada:
Lista o que no. Si lo est, simplemente hacemos que Lista sea Lista->anterior o
Lista->siguiente
Se trata de un caso ms general de los dos casos anteriores..
1. Si nodo apunta a Lista, hacemos que Lista apunte a Lista->anterior (o Lista>siguiente).

2. Hacemos que nodo->anterior->siguiente apunte a nodo->siguiente.
3. Hacemos que nodo->siguiente->anterior apunte a nodo->anterior.
Eliminar un nodo de una lista doblemente enlazada, caso general:

Lista o que no. Si lo est, simplemente hacemos que Lista sea Lista->anterior, si
no es NULL o Lista->siguiente en caso contrario.
1. Si nodo apunta a Lista,
41
Si Lista->anterior no es NULL hacemos que Lista apunte a Lista>anterior.

o Si Lista->siguiente no es NULL hacemos que Lista apunte a Lista>siguiente.
o Si ambos son NULL, hacemos que Lista sea NULL.
2. Si nodo->anterior no es NULL, hacemos que nodo->anterior->siguiente
apunte a nodo->siguiente.
3. Si nodo->siguiente no es NULL, hacemos que nodo->siguiente->anterior
apunte a nodo->anterior.
o
3.7 Ejemplo de lista doblemente enlazada en C:

Como en el caso de los ejemplos anteriores, construiremos una lista doblemente
enlazada para almacenar nmeros enteros. Para aprovechar mejor las
posibilidades de estas listas, haremos que la lista est ordenada. Haremos
pruebas insertando varios valores, buscndolos y eliminndolos alternativamente
para comprobar el resultado.
Algoritmo de insercin:
1. El primer paso es crear un nodo para el dato que vamos a insertar.
2. Si Lista est vaca, o el valor del primer elemento de la lista es mayor que el
del nuevo, insertaremos el nuevo nodo en la primera posicin de la lista.
3. En caso contrario, buscaremos el lugar adecuado para la insercin,
tenemos un puntero "anterior". Lo inicializamos con el valor de Lista, y
avanzaremos mientras anterior->siguiente no sea NULL y el dato que
contiene anterior->siguiente sea menor o igual que el dato que queremos
insertar.
4. Ahora ya tenemos anterior sealando al nodo adecuado, as que
insertamos el nuevo nodo a continuacin de l.

pNodo nuevo, actual;
nuevo->valor = v;
/* Colocamos actual en la primera posicin de la
lista */
actual = *lista;
if(actual) while(actual->anterior) actual =
actual->anterior;
42
/* Si la lista est vaca o el primer miembro es

mayor que el nuevo */
if(!actual || actual->valor > v) {
nodo */
nuevo->siguiente = actual;
nuevo->anterior = NULL;
if(actual) actual->anterior = nuevo;
if(!*lista) *lista = nuevo;
}
else {
while(actual->siguiente &&actual->siguiente>valor <= v)
actual = actual->siguiente;
anterior */
nuevo->siguiente = actual->siguiente;
actual->siguiente = nuevo;
nuevo->anterior = actual;
if(nuevo->siguiente) nuevo->siguiente>anterior = nuevo;
}
}
Algoritmo de la funcin "Borrar":
1. Localizamos el nodo de valor v
2. Existe?
o SI:
Es el nodo apuntado por lista?
SI: Hacer que lista apunte a otro sitio.
Es el primer nodo de la lista?
NO: nodo->anterior->siguiente = nodo->siguiente
Es el ltimo nodo de la lista?
NO: nodo->siguiente->anterior = nodo->anterior
Borrar nodo
43

pNodo nodo;
/* Buscar el nodo de valor v */
nodo = *lista;
while(nodo && nodo->valor <v) nodo = nodo>siguiente;
while(nodo && nodo->valor > v) nodo = nodo>anterior;
/* El valor v no est en la lista */
/* Borrar el nodo */
/* Si lista apunta al nodo que queremos borrar,
apuntar a otro */
if(nodo == *lista)
if(nodo->anterior) *lista = nodo->anterior;
else *lista = nodo->siguiente;
if(nodo->anterior) /* no es el primer elemento */
nodo->anterior->siguiente = nodo->siguiente;
if(nodo->siguiente) /* no es el ltimo nodo */
nodo->siguiente->anterior = nodo->anterior;
free(nodo);
}
Tan slo nos queda escribir una pequea prueba para verificar el funcionamiento:
#include <stdio.h>
#define ASCENDENTE 1
#define DESCENDENTE 0
int valor;
44

} tipoNodo;
/* Funciones con listas: */
void MostrarLista(Lista l, int orden);
int main() {
Lista lista = NULL;
pNodo p;
Insertar(&lista,
Insertar(&lista,
Insertar(&lista,
Insertar(&lista,
20);
10);
40);
30);
MostrarLista(lista, ASCENDENTE);
MostrarLista(lista, DESCENDENTE);
Borrar(&lista,
Borrar(&lista,
Borrar(&lista,
Borrar(&lista,
10);
15);
45);
30);
MostrarLista(lista, ASCENDENTE);
MostrarLista(lista, DESCENDENTE);
getchar();
return 0;
45

pNodo nuevo, actual;
nuevo->valor = v;
/* Colocamos actual en la primera posicin de la
lista */
actual = *lista;
if(actual) while(actual->anterior) actual =
actual->anterior;
/* Si la lista est vaca o el primer miembro es
mayor que el nuevo */
if(!actual || actual->valor > v) {
nodo */
nuevo->siguiente = actual;
nuevo->anterior = NULL;
if(actual) actual->anterior = nuevo;
if(!*lista) *lista = nuevo;
}
else {
while(actual->siguiente &&actual->siguiente>valor <= v)
anterior */
nuevo->siguiente = actual->siguiente;
actual->siguiente = nuevo;
nuevo->anterior = actual;
if(nuevo->siguiente) nuevo->siguiente>anterior = nuevo;
}
}
46

pNodo nodo;
/* Buscar el nodo de valor v */
nodo = *lista;
while(nodo && nodo->valor < v) nodo = nodo>siguiente;
while(nodo && nodo->valor > v) nodo = nodo>anterior;
/* El valor v no est en la lista */
/* Borrar el nodo */
/* Si lista apunta al nodo que queremos borrar,
apuntar a otro */
if(nodo == *lista)
if(nodo->anterior) *lista = nodo->anterior;
else *lista = nodo->siguiente;
if(nodo->anterior) /* no es el primer elemento */

nodo->anterior->siguiente = nodo->siguiente;
if(nodo->siguiente) /* no es el ltimo nodo */
nodo->siguiente->anterior = nodo->anterior;
free(nodo);

pNodo nodo, actual;
actual = *lista;
while(actual->anterior) actual = actual>anterior;
while(actual) {
nodo = actual;
free(nodo);
47
}
*lista = NULL;
void MostrarLista(Lista lista, int orden) {

pNodo nodo = lista;
if(!lista) printf("Lista vaca");
nodo = lista;
if(orden == ASCENDENTE) {
while(nodo->anterior) nodo = nodo->anterior;
printf("Orden ascendente: ");
while(nodo) {
}
}
else {
while(nodo->siguiente) nodo = nodo->siguiente;
printf("Orden descendente: ");
while(nodo) {
nodo = nodo->anterior;
}
}
}
printf("\n");
48
CONCLUSION
Una de las aplicaciones ms interesantes y potentes de la memoria dinmica y los
punteros son las estructuras dinmicas de datos. Las estructuras bsicas
disponibles en C y C++ tienen una importante limitacin: no pueden cambiar de
tamao durante la ejecucin. Los arreglos estn compuestos por un determinado
nmero de elementos, nmero que se decide en la fase de diseo, antes de que el
programa ejecutable sea creado.
En muchas ocasiones se necesitan estructuras que puedan cambiar de tamao
durante la ejecucin del programa. Por supuesto, podemos hacer 'arrays'
dinmicos, pero una vez creados, tu tamao tambin ser fijo, y para hacer que
crezcan o diminuyan de tamao, deberemos reconstruirlas desde el principio.
Las estructuras dinmicas nos permiten crear estructuras de datos que se adapten
a las necesidades reales a las que suelen enfrentarse nuestros programas. Pero
no slo eso, como veremos, tambin nos permitirn crear estructuras de datos
muy flexibles, ya sea en cuanto al orden, la estructura interna o las relaciones
entre los elementos que las componen.
Las estructuras de datos estn compuestas de otras pequeas estructuras a las
que llamaremos nodos o elementos, que agrupan los datos con los que trabajar
49
nuestro programa y adems uno o ms punteros autoreferenciales, es decir,

punteros a objetos del mismo tipo nodo.
Una estructura bsica de un nodo para crear listas de datos seria:
struct nodo {
int dato;
struct nodo *otronodo;
};
El campo "otronodo" puede apuntar a un objeto del tipo nodo. De este modo, cada
nodo puede usarse como un ladrillo para construir listas de datos, y cada uno
mantendr ciertas relaciones con otros nodos.
Para acceder a un nodo de la estructura slo necesitaremos un puntero a un nodo.
Durante el presente curso usaremos grficos para mostrar la estructura de las
estructuras de datos dinmicas. El nodo anterior se representar as:
Las estructuras dinmicas son una implementacin de TDAs o TADs (Tipos

Abstractos de Datos). En estos tipos el inters se centra ms en la estructura de
los datos que en el tipo concreto de informacin que almacenan.
Dependiendo del nmero de punteros y de las relaciones entre nodos, podemos
distinguir varios tipos de estructuras dinmicas. Enumeraremos ahora slo de los
tipos bsicos que hemos tratado en este trabajo:
Listas abiertas: cada elemento slo dispone de un puntero, que apuntar al

siguiente elemento de la lista o valdr NULL si es el ltimo elemento.
Listas circulares: o listas cerradas, son parecidas a las listas abiertas, pero
el ltimo elemento apunta al primero. De hecho, en las listas circulares no
puede hablarse de "primero" ni de "ltimo". Cualquier nodo puede ser el
nodo de entrada y salida.
Listas doblemente enlazadas: cada elemento dispone de dos punteros, uno
a punta al siguiente elemento y el otro al elemento anterior. Al contrario que
las listas abiertas anteriores, estas listas pueden recorrerse en los dos
sentidos.
Los otros tipos de estructuras dinmicas son: Listas, Colas, rboles, rboles
Binarios, rboles Binarios de Bsqueda, rboles AVL, rboles B, Tablas HASH,
Grafos y Diccionarios, entre otros.
50
Tambin existen estructuras dinmicas en las que existen nodos de distintos tipos,
en realidad no es obligatorio que las estructuras dinmicas estn compuestas por
un nico tipo de nodo, la flexibilidad y los tipos de estructuras slo estn limitados
por tu imaginacin como programador.
BIBLIOGRAFIA
Estructuras dinmicas de datos. Algoritmos, acceso, propiedades, ejemplos.
Direccin Pgina Web: http://c.conclase.net/edd/index.php?cap=000
INSTITUTO TECNOLOGICO de La Paz. Tutorial de Estructura de Datos.
Direccin Pgina Web: http://www.itlp.edu.mx/publica/tutoriales/estru1/
ALGORITMIA ALGO+ - Algoritmos y Estructuras de Datos.
Direccin Pgina Web: http://www.algoritmia.net/articles.php?id=13
100cia.com > Portada > Enciclopedia > Estructura_de_datos.
Direccin Pgina Web: http://www.100cia.com/enciclopedia/Estructura_de_datos
El Rincn del Programador. Programacin Genrica. Estructura de Datos. Listas.
Direccin Pgina Web:
http://rinconprog.metropoliglobal.com/CursosProg/ProgGen/Estr_Datos/index.php?
cap=4
51
52

Listas Lenguaje C

Загружено:

Сведения о документе

Исходное описание:

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Listas Lenguaje C

Загружено:

Авторское право:

Доступные форматы

INTRODUCCION

El siguiente trabajo ser realizado con la finalidad de referir los conocimientos

a(1), a(2), a(3), ... , a(n)

Si se desea aadir el valor 'Fernando' a esta lista ordenada de nombres, la

otro lado, si suponemos que lo que se desea es borrar de la lista el elemento

Cada elemento de la lista contiene un campo informacin (nombre) ms otro

donde se desea insertar el nombre 'Fernando'. Su posicin correcta dentro de la

-Un mecanismo para definir la estructura de un nodo.

Una lista enlazada o encadenada es una coleccin de elementos nodos, en

Una manera de clasificarlas es por la forma de acceder al siguiente

Insertar un nodo al inicio.

typedef struct _nodo {

Aadir o insertar elementos.

Insertar un elemento en una lista vaca:

El proceso es muy simple, bastar con que:

El proceso sigue siendo muy sencillo:

Insertar un elemento en la ltima posicin de una lista:

El proceso en este caso tampoco es excesivamente complicado:

Insertar un elemento a continuacin de un nodo cualquiera de una lista:

1.5 Localizar elementos en una lista abierta:

typedef struct _nodo {

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

Si la lista slo tiene un nodo, el proceso es tambin vlido, ya que el valor de

El proceso es parecido al del caso anterior:

Si el nodo a eliminar es el ltimo, es procedimiento es igualmente vlido, ya que

Primer elemento de una lista:

void Insertar(Lista *lista, int v) {

/* Insertamos el nuevo nodo despus del nodo

void Borrar(Lista *lista, int v) {

while(nodo && nodo->valor < v) {

Cdigo del ejemplo completo:

void BorrarLista(Lista *lista) {

void MostrarLista(Lista lista) {

typedef struct _nodo {

Aadir o insertar elementos.

El proceso es muy simple, bastar con que:

Aadir elemento en una lista circular no vaca:

De nuevo partiremos de un nodo a insertar, con un puntero que apunte a l, y de

El proceso sigue siendo muy sencillo:

Aadir elemento en una lista circular, caso general:

En el primer caso necesitamos localizar el nodo anterior al que queremos borrar.

1. El primer paso es conseguir que lista apunte al nodo anterior al que

Eliminar el nico nodo en una lista circular:

Supongamos que queremos eliminar un nodo apuntado por nodo:

Copiamos el contenido del nodo->siguiente sobre el contenido de nodo.

void Insertar(Lista *lista, int v) {

// Si la lista est vaca, la lista ser el nuevo

void Borrar(Lista *lista, int v) {

// Hacer que lista apunte al nodo anterior al de

Listas doblemente enlazadas

typedef struct _nodo {

El movimiento a travs de listas doblemente enlazadas es ms sencillo, y como

Aadir o insertar elementos.

3.4 Aadir un elemento:

Aadir elemento en una lista doblemente enlazada vaca:

El proceso es muy simple, bastar con que:

Insertar un elemento en la primera posicin de la lista:

Insertar un elemento a continuacin de un nodo cualquiera de una lista:

El proceso sigue siendo muy sencillo:

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

Los pasos 2 y 3 equivalen a la insercin en una lista enlazada corriente.

typedef struct _nodo {

typedef tipoNodo *pNodo;