listas enlazadas

UAA – Sistemas Electrónicos Estructura de Datos Eduardo Serna-Pérez

1

4 Listas enlazadas La lista enlazada es una de las estructuras de datos más versátiles, consiste en una secuencia de elementos heterogéneos llamados nodos, cada uno de ellos contiene arbitrariamente al menos un campo dato, en el cual podemos almacenar algún tipo de información y una o dos referencias llamadas enlaces, que almacenan la posición al nodo siguiente o previo. De manera que una lista enlazada es un tipo de dato con elementos (nodos) auto-referenciados debido a que cada nodo contiene un puntero o enlace a otro dato del mismo tipo.

info

nodo

sig raíz

info

nodo

sig

info

nodo

sig

null

La lista enlazada se accede a partir de un puntero externo llamado nodo raíz que apunta al primer nodo de la lista, cada campo del nodo esta compuesto (en su instancia más simple) de un campo información (info) y un campo siguiente (sig) que contiene la dirección del nodo consecutivo. El campo siguiente del último nodo de la lista contiene un valor especial llamado nulo (null) que indica el fin de la lista.

4.1 Estructuras auto-referenciadas Concepto de Nodo: es una estructura de datos abstracta, donde los nodos se caracterizan por ser un tipo de dato auto-referenciado, debido a que uno de sus componentes (el campo siguiente) es un puntero a una estructura del mismo tipo del nodo. De esta manera es posible realizar los enlaces entre nodo y nodo. Además de contener al menos un campo dato donde podemos almacenar información, a continuación vemos una definición de Nodo en el lenguaje C++:

ANSI C++ ANSI C++ (clase) struct Nodo { int info; Nodo * sig; };

info (int)

sig (Nodo*)

class Nodo { public: //constructor private: int info; Nodo * sig; };

Apuntador a Nodo: el nodo raíz y el campo siguiente de cada nodo serán de tipo apuntador a nodo, debido a que son estructuras inherentemente dinámicas que almacenaran direcciones de memoria de cada uno de los nodos que se vayan generando en tiempo de ejecución. En C/C++ se suelen emplear alias (typedef) para renombrar nuevos tipos estructurados como las auto-referenciadas ya que facilitan su uso, veremos más adelante que en lenguajes que implementan las orientación a objetos de manera persistente no es necesario:

typedef nodo* pNodo; De esta forma se dice que pNodo es un puntero a una estructura de tipo nodo, por lo que las variables de este tipo únicamente serán capaces de almacenar direcciones de memoria.


2

Apuntador Nulo: los punteros son asignados inicialmente a un valor vació o nulo (NULL) que representa sin dirección de memoria asignada, por lo general se dice que el ultimo nodo de la lista no apunta a algún lugar en especial en la memoria, esta constante NULL suele ser empleada para identificar el fin de la lista en la mayoría de los casos.

pNodo raiz = NULL; A continuación se presenta un programa sencillo que crea una lista simple que contiene únicamente un nodo. Observe que la instrucción new crea un bloque de memoria necesario para contener una estructura de tipo Nodo.

#include <iostream> using namespace std; struct Nodo { int info; Nodo* sig; }; typedef Nodo* pNodo; int main () { pNodo raiz = NULL, nuevo; nuevo = new Nodo; nuevo->info = 6; nuevo->sig = NULL; raiz = nuevo; cout << raiz->info << endl; cout << raiz->sig << endl; delete raiz; return 0; }

raíz

info 6

nuevo

sig

null

Una lista con un solo elemento no resulta una estructura de datos interesante, además de estar muy acotada, por ello nos abocaremos a la construcción de estructuras de datos más complejas, elaboradas y funcionales. Antes que nada es necesario identificar primeramente las diversas clases de listas enlazadas que existen; y analizaremos los diversos algoritmos existentes para realizar operaciones que pueden realizarse con ellas, tales como la inserción de elementos, el borrado de los mismos, la búsqueda de datos, entre otras operaciones indispensables para su manipulación apropiada. Existen al menos tres clases de listas enlazadas:

o Listas simples enlazadas o Listas simples circulares o Listas dobles

4.1.1 Listas simples enlazadas Las listas permiten operaciones como la inserción y remoción de nodos en cualquier punto de la misma en un tiempo constante de ejecución, es importante recordar que la listas son elementos inherentemente dinámicos y tiene que ser manipulados en tiempo de ejecución. Las listas simples ligadas son el tipo de lista más sencillo de implementar y quizás uno de los más útiles al momento de elaborar alguna herramienta de programación, debido a que su esquema puede ser fácilmente adaptado para generar pilas y colas dinámicas. Las listas simples son colecciones de datos enlazados por un campo de auto-referencia (siguiente), donde el último elemento apunta a una dirección (null) que representa el fin de la colección como se mostró en el dibujo del inicio de la sección.


3

Las operaciones más comunes en una lista enlazada son: insertar, eliminar y recorrer, pero como veremos dichas operaciones suelen diversificarse generando versiones más elaboradas de las mismas para cada tipo de lista, a continuación se mostraran los algoritmos correspondientes a algunas de esas variantes para una lista simple enlazada. Como podrá darse cuenta algunos de estos algoritmos pueden ser útiles al momento de diseñar pilas y colas dinámicas, o algún otro tipo de programa que implemente dichos mecanismos. Algoritmo para insertar un nodo al inicio de la lista: este algoritmo inserta elementos justo después del nodo raíz, por lo que cada nodo insertado justo después de raíz será considerado como el primer nodo. Como podemos intuir siempre el primer nodo que se inserte apuntara al valor de raíz, es decir null, por lo que estará confinado a permanecer al final de la lista. raiz = null repetir {

crea( nuevo ) nuevo->info = valor (a) nuevo->sig = raiz (b) raiz = nuevo (c)

} hasta que no se inserten mas nodos El algoritmo crea un nuevo nodo y posteriormente se almacena el valor correspondiente dentro de la parte información del nuevo nodo (a). Después será necesario insertar el nuevo nodo en la lista, para ello se le asigna la dirección contenida en raíz (primer nodo) al nuevo nodo en su parte siguiente (b). Finalmente será necesario como último paso asignar la dirección del nuevo nodo al nodo raíz de manera que raíz se preserva como el puntero de inicio y el nuevo nodo para ser el primero en la lista (c). El proceso concluye con una lista enlazada (d). Podemos observar que 2 fue el primero en ser insertado y después 8, 5 y finalmente 6.

5

raíz

8

2

null

6

nuevo

(a)

5

raíz

8

2

null

6

nuevo

(b)

5

raíz

8

2

null

6

nuevo

(c)

5

raíz 8

2

null

6

(d)


4

Algoritmo para eliminar al inicio de la lista: este algoritmo se encarga de eliminar justo el primer nodo al que apunta la raíz por lo que el puntero raíz tendrá que ser reasignado al nodo primero en su parte siguiente, de manera que el nodo raíz apuntara al siguiente elemento en la lista. En caso de eliminar el último nodo de la lista, raíz apuntara a null. si ( raíz != null ) { (a) tempo = raiz (b) raiz = raiz->sig (c) elimina( tempo ) (d) } La siguiente secuencia de figuras muestran los pasos realizados a lo largo del proceso de eliminación del primer nodo de la lista. Lo primero es verificar si existen nodos en la lista (a), una vez verificado esto se asigna la dirección del primer nodo a un nodo temporal (tempo), de esta manera obtenemos la dirección del nodo que mas tarde eliminaremos. Después raíz es asignado al siguiente nodo de la lista (c) y finalmente se elimina el nodo temporal (d).

5

raíz 8

2

null

6

(a)

5

raíz

8

2

null

6

tempo

(b)

5

raíz

8

2

null

6

tempo

(c)

5

raíz

8

2

null

6

tempo

(d)

Algoritmo para recorrer una lista: este algoritmo nos permite recorrer todos los elementos de la lista a partir del inicio, para ello asignamos la dirección del nodo de inicio (raíz) a un nodo temporal, mientras la lista no este vacía vamos mostrando la información del nodo, será necesario asignar la dirección del siguiente nodo a temporal, de manera que el recorrido se vaya realizando. tempo = raiz mientras ( tempo != null ) { imprimir( tempo->info ) tempo = nodo->sig }


5

Con los algoritmos ya vistos es posible construir un programa que realice las operaciones básicas de una pila dinámica: insertar, eliminar y mostrar. En este esquema consideraremos al nodo raíz como el tope de la pila dinámica.

5

tope 8

2

null

6

A continuación se muestra un programa en C++ que pueda realizar las operaciones antes mencionadas para un esquema de pila dinámica, tome en cuenta que el programa básico puede adaptarse a las necesidades del programador variando el mecanismo de las funciones. #include <iostream> /* Implementa una lista como una pila dinamica */ using namespace std; struct Nodo { int info; Nodo *sig; }; typedef Nodo* pNodo; /* funciones con listas: */ void insertar( pNodo *, int ); // inserta al frente pNodo eliminar( pNodo * ); // elimina al frente void mostrar( pNodo ); // muestra la lista como pila bool esVacia( pNodo ); // pregunta si esta vacia void vaciarLista( pNodo * ); // elimina la lista completa int main() { pNodo tope = NULL; int op, valor; do { pNodo t = NULL; cout << "Pila dinamica\n1) insertar\n2) eliminar\n3) mostrar\n4) salir\n"; cin >> op; switch (op) { case 1: cout << "insertar ? "; cin >> valor; // &tope manda la direccion de la variable tope insertar(&tope, valor); break; case 2: t = eliminar(&tope); cout << "se elimino " << t->info << endl; delete t; // libera nodo break; case 3: cout << "tope -> "; mostrar(tope); break; } } while (op != 4); vaciarLista(&tope); return 0; } // recibe la direccion de un puntero de alli pNodo * en lista void insertar(pNodo *lista, int val) { // inserta al frente pNodo nuevo; /* crear un nuevo nodo */ nuevo = new Nodo; nuevo->info = val; nuevo->sig = NULL; nuevo->sig = *lista; /* agregamos el nuevo nodo al inicio de la lista */ *lista = nuevo; /* ahora, el comienzo de lista es nuevo nodo */ }


6

pNodo eliminar(pNodo *lista) { // elimina al frente de la lista pNodo tempo = NULL; if (*lista != NULL){ // lista apunta al inicio de la lista tempo = *lista; *lista = tempo->sig; // lista apunta al siguiente nodo } return tempo; } void mostrar(pNodo lista) { pNodo tempo = lista; while( tempo ) { // mientras no sea null cout << tempo->info; tempo = tempo->sig; } cout << endl; } bool esVacia(pNodo lista) { return (lista == NULL); // lista igual a nulo } void vaciarLista(pNodo *lista) { pNodo tempo; while( !esVacia(*lista) ) { // mientras no se llegue a nulo tempo = *lista; // tempo apunta al inicio de la lista *lista = tempo->sig; // lista apunta al siguiente nodo delete tempo; // libera tempo } } Los algoritmos de inserción y borrado desde inicio, así como el de recorrido (mostrar) están implementados en el programa antes visto, adicionalmente se agrego la función esVacío como una manera de hacer más evidente la construcción de operaciones básicas con estructuras de datos. Por último es necesario crear una función que nos permita eliminar todos los nodos creados en tiempo de ejecución (vaciarLista) de manera de que la memoria esté disponible y lista para una futura ejecución de programas. Recordando el funcionamiento de una cola, el primer elemento en entrar es el primer elemento en salir (FIFO), para el caso de una cola dinamica se podrían necesitar dos elementos auxiliares: una referencia al inicio de la cola y una referencia al último elemento de la cola. Los siguientes dos algoritmos pueden ser utilizados para implementar una cola dinámica. Algoritmo para insertar un nodo al final de la lista: en este algoritmo se insertara un nuevo nodo al final de la lista. Para ello será necesario conservar dos punteros uno al inicio y otro al último de la lista, de manera que no sea necesario recorrer toda la lista cada vez que se requiera insertar un elemento. El ultimo puntero nos indica la posición en la que se insertara el nuevo nodo, y una vez hecho esto la dirección al último nodo deberá ser actualizada. inicio = ultimo = null repetir {

crea( nuevo ) nuevo->info = valor nuevo->sig = null si ( ultimo == null ) inicio = nuevo sino

ultimo->sig = nuevo ultimo = nuevo

} hasta que no se inserten mas nodos


7

inicio 2

null

ultimo 6

null

nuevo

ultimo

Ahora, ya con el algoritmo de inserción al final de la lista estamos en posibilidades de implementar un esquema de cola dinámica.

6

inicio 5

null

2

ultimo

En esencia casi se conservan todas las operaciones del programa anterior. La función de inserción se modifica, pues ahora será necesario manipular dos punteros, uno al inicio y otro para el último nodo de la cola dinámica (atrás), de manera que último siempre conserve la referencia al final de la cola. Algoritmo para eliminar un nodo al frente de la lista con inicio y último: Es importante poner especial atención en la función de eliminar, pues cuando ya no se cuenten con más elementos en la cola, será necesario que tanto inicio como último apunten a null. De manera que la cola este lista y en posibilidades de comenzar nuevamente su función. tempo = null si ( inicio != null ) { tempo = inicio inicio = tempo->sig si ( inicio == null ) ultimo = null } regresa tempo A continuación se muestra un programa en C++ que pueda realizar las operaciones antes mencionadas para un esquema de cola dinámica, tome en cuenta que el programa básico puede adaptarse a las necesidades del programador variando el mecanismo de las funciones. /* implementacion de una lista como cola dinámica para este caso se recomienda el empleo de un puntero adicional al nodo raÌz que haga la labor de la parte trasera de la cola */ #include <iostream> using namespace std; // estructura nodo struct Nodo { int info; Nodo *sig; }; // definicion de tipos typedef Nodo* pNodo; /* declaracion de Funciones con listas: */ void insertarAtras( pNodo &, pNodo &, int ); pNodo extraer( pNodo &, pNodo & ); void mostrar( pNodo ); int esVacia( pNodo ); void vaciarLista( pNodo &, pNodo & );


8

int main() { pNodo frente = NULL, atras = NULL, t = NULL; int op, valor; do { cout << " 1 insertar\n 2 extraer\n 3 mostrar\n 4 Salir\n"; cin >> op; switch (op) { case 1: cout << "valor "; cin >> valor; insertarAtras(frente, atras, valor); break; case 2: t = extraer(frente, atras); if (t != NULL) cout << " se extrajo " << t->info << endl; else cout << "cola vacia !!!\n"; delete t; break; case 3: cout << "frente -> "; mostrar(frente); break; } } while (op != 4); vaciarLista(frente, atras); return 0; } void insertarAtras(pNodo &frente, pNodo &atras, int val) { // insertar un elemento al final pNodo nuevo; nuevo = new Nodo; nuevo->info = val; nuevo->sig = NULL; if ( atras == NULL ) frente = nuevo; else atras->sig = nuevo; atras = nuevo; } pNodo extraer(pNodo &frente, pNodo &atras) { // extraer un elemento al frente de la cola pNodo tempo = NULL; if (frente != NULL) { tempo = frente; // nodo apunta al inicio de la cola frente = tempo->sig; // lista apunta al siguiente nodo if ( frente == NULL ) atras = NULL; // no hay mas elementos en la cola } return tempo; } void mostrar(pNodo lista) { for(pNodo nodo = lista; !esVacia(nodo); nodo = nodo->sig ) cout << nodo->info << " -> "; cout << "null\n"; } int esVacia(pNodo lista) { return (lista == NULL); } // lista igual a nulo void vaciarLista(pNodo &frente, pNodo &atras) { pNodo tempo; while( !esVacia(frente) ) { // mientras no se llege a nulo tempo = frente; // tempo apunta al inicio de la lista frente = tempo->sig; // lista apunta al siguiente nodo if ( frente == NULL ) atras = NULL; delete tempo; // libera tempo } }


9

Se deja como caso de estudio el generar una lista ordenada de elementos en la cual se persigue que conforme se ingresan los datos en la lista, los valores serán insertados según su valor dentro de la lista.

4.1.2 Listas simples circulares Una lista enlazada circular posee una característica adicional y es que su estructura parecería que no tiene fin ya que el primero y el último nodo están unidos bajo una misma referencia. Para que la lista sea sin fin, el puntero siguiente del último elemento apuntará hacia el 1er elemento de la lista en lugar de apuntar al valor NULL. Para recorrer una lista enlazada circular podemos empezar por cualquier nodo y seguir la lista en cualquier dirección hasta que se regrese hasta el nodo original. Desde otro punto de vista, las listas enlazadas circulares pueden ser vistas como listas sin comienzo ni fin. Este tipo de listas es el más usado para dirigir buffers para “ingerir” datos, y para visitar todos los nodos de una lista a partir de un nodo dado.

info

nodo

sig

raíz info

nodo

sig

info

nodo

sig primero último

Debido a que las listas circulares no cuentan de manera natural con un nodo primero y último, debe de establecerse una convención para el manejo del nodo primero y último. De manera que el nodo raíz apunta siempre al último nodo de la lista lo que le permite acceder de manera natural al último nodo y la referencia raíz->sig le permite acceder al primer nodo de la lista como se muestra en la figura anterior. Esta característica de las listas circulares facilita la inserción de nodos al inicio o al final, así es posible generar pilas y colas dinámicas más fácilmente. Algoritmo para insertar un nodo al final de la lista circular: este algoritmo inserta elementos justo después del nodo raíz, de manera que en cada inserción raíz apuntara al último elemento de la lista, mientras que raíz->sig apunta al primer nodo de la lista. raiz = null repetir {

crea( nuevo ) nuevo->info = valor si raiz == null entonces

raíz = nuevo sino

nuevo->sig = raíz->sig fin si

raíz->sig = nuevo raíz = nuevo } hasta que no se inserten mas nodos


10

2

raíz nuevo

2

6

raíz raiz nuevo

Algoritmo para eliminar un nodo al inicio de la lista circular: ahora eliminaremos el nodo que se encuentra justo al inicio de la lista, este nodo puede ser alcanzado a partir del nodo raíz en su parte siguiente raíz->sig. De manera que el nodo del frente se supone será atendido y la referencia deberá de ir ahora al siguiente nodo en la cola. tempo = null si ( raíz != null ) { tempo = raíz->sig raíz->sig = tempo->sig elimina( tempo ) } Algoritmo para recorrer una lista circular: el algoritmo permite recorrer todos los elementos de la lista a partir del nodo raíz, para ello asignamos la dirección del nodo de inicio (raíz) a un nodo temporal, mientras la lista no este vacía vamos mostrando la información del nodo, será necesario asignar la dirección del siguiente nodo a temporal, de manera que el recorrido se vaya realizando. tempo = raíz->sig si (raiz == null) return mientras ( tempo != raiz ) { imprimir( tempo->info ) tempo = tempo->sig }

2

6

raíz

8

tempo tempo


11

Apéndice A

Manejo de argumentos en la función main Todos los programas que se construyen en el lenguaje ANSI C/C++ tienen la capacidad de recibir argumentos de entrada, esto se debe principalmente a la capacidad que tiene la función main de recoger o recibir dichos argumentos de entrada y depositarlos en variables pertinentes para su uso. La función main recibe un par de argumentos:

int main ( int argc, char *argv[] ) El primer argumento, denominado argc (abreviatura en ingles para “argument count”) es una variable entera que determina la cantidad de elementos de entrada separados por un espacio en blanco (token), mientras que el segundo argumento, denominado como argv (abreviatura en ingles para ”argument vector”) es un arreglo de punteros tipo char que almacena cada una de las constantes literales (tokens) introducidos en la línea de comandos. Ambos argumentos en la función main, argc y argv son muy útiles cuando pretendemos que nuestro programa capture valores de entrada desde la línea de comandos. Todos los programas de computadora requieren al menos un cierto número de argumentos de entrada, ya que estos dan versatilidad y opciones de uso a un cierto programa. Por ejemplo el mismo compilador de ANSI C/C++ requiere argumentos de entrada para poder trabajar, quizás esto ya no sea tan perceptible al programador, pues los ambientes de desarrollo han ido cubriendo esta necesidad de manejo de argumentos, un ambiente de desarrollo en realidad manda llamar a otro programa denominado compilador que tomará la entrada de argumentos y realizara un proceso de compilado. En los ambientes tipo UNIX, existen compiladores de C llamado gcc, y otro de C++ llamado g++, éstos requiere algunos argumentos de entrada para poder hacer su labor de compilación:

g++ –o miprograma miprograma.cpp Entonces g++ es el compilador (programa) y los argumentos de entrada son las literales “–o“, “miprograma” y “miprograma.cpp”, estas literales serán usadas por el compilador para generar el programa de manera que se solicito. Es importante recordad que la ejecución de programas desde la línea de comando ha sido gradualmente sustituida por elementos de programación más poderosos, pero sin embargo la ejecución desde línea de comando es una de las formas más rápidas de ejecución. De esta forma los programas que construyamos en C/C++ tendrán esa misma característica para el manejo de argumentos. Veamos un ejemplo muy simple que muestra el uso de argumentos de entrada, en este caso emplearemos argc para determinar la cantidad de argumentos de entrada y argv para mostrar el contenido del arreglo de caracteres que contiene a cada argumento que ha ingresado. #include <iostream> using namespace std; int main(int argc, char *argv[]) { cout << "numero de argumentos " << argc << endl; for(int i = 0; i < argc; i++) cout << argv[i] << endl;


12

return 0; } El programa será salvado con el nombre tempo.cpp, el compilador entonces generara un programa llamado tempo.exe, que es precisamente el programa que se ejecutara desde la línea de comandos de la siguiente manera:

C:\Mi Directorio\tempo.exe Hola mundo Las literales Hola y mundo serán recibidos por argv y contados por argc, de manera que producirá la siguiente salida:

numero de argumentos 3 C:\Mi Directorio\tempo.exe Hola mundo Presione una tecla para continuar . . .

Tome en cuenta que el nombre de nuestro programa así como la ruta en que lo ejecutemos será el primer argumento (argv[0]). Recuerde que los argumentos de entrada también pueden ser ingresados desde el ambiente de desarrollo, por ejemplo en Dev-C++ se encuentran en menú Excecute à Parameters…


13

Bibliografía Garcia de Jalon, Javier et al. “Aprenda lenguaje ANSI C: Como si estuviera en primero”, Universidad de Navarra. Harvey Deitel & Paul Deitel, “Cómo programar en C”, Prentice Hall, segunda edición, 1999, ISBN 970-17-0254-9. Naba Barkakati, “Turbo C/C++ Bible”, Sams first edition, 1992, ISBN 0-672-22742-8. Y. Langsam, M. J. Augenstein, A. Tenenbaum. Data Structures using C and C++. Prentice Hall, Second edition. ISBN 0-13-036997-7.

listas enlazadas

Documents