ESTRUCTURAS DE DATOS

LISTAS
CONCEPTO DE LISTAS
Las listas de acuerdo a su estructura se han dividido en cuatro grandes
categoras:
1.- Listas Simplemente enlazadas
2.- Listas Doblemente enlazadas
3.- Listas Circular simplemente enlazada
4.- Lista circular doblemente enlazada
Lista simplemente enlazada
Lista contigua: Es un conjunto de elementos de un tipo dado que se
encuentran ordenados y pueden variar en nmero. Esta es una
definicin general, que incluye los ficheros y vectores.
Las entradas de una gua o directorio telefnico, por ejemplo, estn en
lneas sucesivas, excepto en las partes superior e inferior de cada
columna. Una lista lineal se almacena en la memoria principal de una
computadora en posiciones sucesivas de memoria; cuando se
almacenan en cinta magntica, los elementos sucesivos se presentan
en sucesin en la cinta. Esta asignacin de memoria se denomina
almacenamiento secuencial. Posteriormente, se ver que existe otro
tipo de almacenamiento denominado encadenado o enlazado.
Una lista lineal se almacena en la memoria de la computadora en
posiciones sucesivas o adyacentes y se procesa como un array
unidimensional. En este caso, el acceso a cualquier elemento de la lista
es fcil; sin embargo, la insercin o borrado requiere un
desplazamiento de lugar de los elementos que le siguen y en
consecuencia el diseo de un algoritmo especfico.
Para permitir operaciones con las listas como arrays se deben
dimensionar stos con tamao suficiente para que contengan todos los
posibles elementos de la lista.
La insercin o eliminacin de un elemento, excepto en la cabecera o
final de la lista, necesita una traslacin de un parte de los elementos de
la misma: la que precede o sigue a la posicin del elemento
modificado.
Las operaciones directas de aadir y eliminar se efectan nicamente
en los extremos de la lista. Esta limitacin es una de las razones por las
que esta estructura es poco utilizada.
Operaciones con las listas simplemente
enlazadas
Las operaciones que se pueden realizar con listas lineales contiguas son:
1. Insertar, eliminar o localizar un elemento.
2. Determinar el tamao nmero de elementos de la lista.
3. Recorrer la lista para localizar un determinado elemento.
4. Clasificar los elementos de la lista en orden ascendente o descendente.
5. Unir dos o ms listas en una sola.
6. Dividir una lista en varias sublistas.
7. Copiar la lista.
8. Borrar la lista.
Representacin grfica de una lista contigua
LISTAS ENLAZADAS
Las listas enlazadas o de almacenamiento enlazado son mucho ms
flexibles y potentes, y su uso es mucho ms amplio que la lista
contigua.
Representacin grafica de una lista enlazada
Una lista enlazada o encadenada es un conjunto de elementos en los que cada
elemento contiene la posicin o direccin del siguiente elemento de la lista.
Cada elemento de la lista enlazada debe tener al menos dos campos: un campo
que tiene el valor del elemento y un campo (enlace, link) que contiene la posicin
del siguiente elemento, es decir, su conexin, enlace o encadenamiento. Los
elementos de una lista son enlazados por medio de los campos enlaces Una lista
enlazada sin ningn elemento se llama lista vaca. Su puntero inicial o de cabecera
tiene el valor nulo (NULL).
Una lista enlazada se define por:
El tipo de sus elementos: campo de informacin (datos) y campo enlace
(puntero).
Un puntero de cabecera que permite acceder al primer elemento de la lista.
Un medio para detectar el ltimo elemento de la lista: puntero nulo (NULL).
Implementacin de Listas Enlazadas
Pues ahora vamos a ver un tipo de estructura totalmente dinmica (que
puedan aumentar o disminuir de tamao durante la ejecucin del
programa).
Ahora "el truco" consistir en que dentro de cada dato almacenaremos todo
lo que nos interesa, pero tambin una referencia que nos dir dnde
tenemos que ir a buscar el siguiente, para estos casos se hace uso de las
estructuras.
Sera algo as como:
(Posicin: 1023).
Nombre : 'Juan Cano '
DireccionInet : '[email protected]'
SiguienteDato : 1430
Hemos perdido la ventaja del acceso directo: ya no podemos saltar
directamente al elemento nmero 500. Pero, por contra, podemos
tener tantos elementos como la memoria nos permita.
Para aadir un nodo, no tendramos ms que reservar la memoria para
el y el compilador de C nos dira "le he encontrado sitio en la posicin
4079". As que nosotros iramos al ltimo elemento y le diramos "tu
siguiente dato va a estar en la posicin 4079".
Esa es la idea "intuitiva". Ahora vamos a concretar cosas en forma de
programa en C.
Primero veamos cmo sera ahora cada una de nuestras fichas:
typedef
struct f /* Estos son los datos que guardamos: */
{
char nombre[30]; /* Nombre, hasta 30 letras */
char direccion[50]; /* Direccion, hasta 50 */
int edad; /* Edad, un numero < 255 */
struct f *siguiente; /* Y direccin de la siguiente */
} Ficha;
La diferencia con un "struct" normal est en el campo "siguiente" de nuestro registro, que es el que
indica donde se encuentra la ficha que va despus de la actual, y por tanto ser otro puntero a un
registro como estos, un "struct f*".
Un puntero que "no apunta a ningn sitio" tiene el valor NULL (realmente este identificador es una
constante de valor 0, como ya hemos comentado), que nos servir despus para comprobar si se
trata del final de la lista: todas las fichas "apuntarn" a la siguiente, menos la ltima, que "no tiene
siguiente", y apuntar a NULL.
Entonces la primera ficha definiramos con:
Ficha *dato1; /* Va a ser un puntero a ficha */
la crearamos con:
dato1 = (Ficha*) malloc (sizeof(Ficha)); /* Reservamos memoria */
strcpy(dato1->nombre, "Pepe"); /* Guardamos el nombre, */
strcpy(dato1->direccion, "Su casa"); /* la direccin */
dato1->edad = 40; /* la edad */
dato1->siguiente = NULL; /* y no hay ninguna ms */
Eso de:
strcpy(dato1->nombre,"Pepe");
es algo que posiblemente tenderamos a escribir as en un principio:
*dato1.nombre = "Pepe";
Pero recordemos que en el lenguaje C no se puede dar valores as a las
cadenas de texto, sino que debemos hacer uso de funciones como "strcpy", y
hacer algo parecido a
strcpy(*dato1.nombre,"Pepe");
Pero esa expresin todava no es correcta del todo. La forma correcta de
escribir que queremos acceder a los campos de un puntero a registro es
usando el operador "->", como se ha indicado anteriormente:
strcpy(dato1->nombre,"Pepe");
Ahora que ya tenemos una ficha, podramos aadir otra ficha detrs de ella.
Primero guardamos espacio para la nueva ficha, como antes:
Ficha *dato2; /* Va a ser otro puntero a ficha */
dato2 = (Ficha*) malloc (sizeof(Ficha)); /* Reservamos memoria */
strcpy(dato2->nombre, "Juan"); /* Guardamos el nombre, */
strcpy(dato2->direccion, "No lo s"); /* la direccin */
dato2->edad = 35; /* la edad */
dato2->siguiente = NULL; /* y no hay ninguna ms */
y ahora enlazamos la anterior con ella:
dato1->siguiente = dato2;
Si quisiramos introducir los datos ordenados alfabticamente, basta
con ir comparando cada nuevo dato con los de la lista, e insertarlo
donde corresponda. Por ejemplo, para insertar un nuevo dato entre los
dos anteriores haramos:
Ficha *dato3; /* Va a ser otro puntero a ficha */
dato3 = (Ficha*) malloc (sizeof(Ficha));
strcpy(dato3->nombre, "Carlos");
strcpy(dato3->direccion, "Por ah");
dato3->edad = 14;
dato3->siguiente = dato2; /* enlazamos con la siguiente */
dato1->siguiente = dato3; /* y la anterior con ella */
La estructura que hemos obtenido es la siguiente
Dato1 - Dato3 - Dato2 - NULL
Es decir: cada ficha est enlazada con la siguiente, salvo la ltima, que no
est enlazada con ninguna (apunta a NULL). Si ahora quisiramos borrar
Dato3, tendramos que seguir dos pasos:
1.- Enlazar Dato1 con Dato2, para no perder informacin.
2.- Liberar la memoria ocupada por Dato3.
Esto, escrito en "C" sera:
dato1->siguiente = dato2; /* Enlaza Dato1 y Dato2 */
free(dato3); /* Libera lo que ocup Dato3 */
Hemos empleado tres variables para guardar tres datos. Si tenemos 20 datos,
necesitaremos 20 variables? Y 3000 variables para 3000 datos? Sera tremendamente
ineficiente, y no tendra mucho sentido. Es de suponer que no sea as. En la prctica, basta
con dos variables, que nos indicarn el principio de la lista y la posicin actual, o incluso
slo una para el principio de la lista.
Por ejemplo, una rutina que muestre en pantalla toda la lista se podra hacer de forma
recursiva as:
void MuestraLista ( Ficha *inicial )
{
if (inicial) /* Si realmente hay lista */
{
printf("Nombre: %s\n", inicial->nombre);
printf("Direccin: %s\n", inicial->direccion);
printf("Edad: %s\n", inicial->edad);
MuestraLista ( inicial->siguiente ); /* Y mira el siguiente */
}
}
Lo llamaramos con "MuestraLista(Dato1)", y a partir de ah el propio procedimiento se
encarga de ir mirando y mostrando los siguientes elementos hasta llegar a NULL, que indica
el final.
Ejemplo del funcionamiento de una lista
Antes de seguir
Revise el cdigo fuente llamado:
listas-enlazada_comprobacion-diap.cpp
para comprobar que realmente funciona todo lo dicho anteriormente:
Se han aadimos 3 datos y decimos que los muestre; luego se borra el
del medio y se vuelve a mostrar
Seor estudiante, Detalle el resultado
Implementacin Completa de una lista
enlazada
Revise el cdigo adjunto llamado:
listas-enlazada_implementacion-completa.cpp
El ejemplo es una gua para implementar una lista simplemente
enlazada con punteros, para gestionar nmeros enteros, ingresados
por teclado con funciones de insertar eliminar recorrer y buscar. Las
eliminaciones y la bsqueda, se realizan en cualquier lugar de la lista