UNIVERSIDAD DIEGO PORTALES Facultad de Ingeniería Programación Avanzada TIPOS ABSTRACTOS DE DATOS TAD Tema: TIPOS ABSTRACTOS DE DATOS TAD Subtema: LISTAS Ing. Javier Chamorro Cerón

Arrays int[5]; 62417

Un NODO es una estructura que contiene un dato y un puntero que apunta hacia una dirección de memoria donde se encuentra otro nodo. Gráficamente sería: NODO Valor Siguiente Advertencia: Siguiente es un PUNTERO que apunta a un nuevo nodo, por esa razón, la clase NODO tiene como atributo un Puntero de tipo NODO. A esa estrategia de programación se la denomina RECURSIVIDAD O RECURSIÓN.

#include using namespace std; class Nodo { private: stringvalor; Nodo *sig; public: Nodo (string valor = "", Nodo *sig = NULL){ this->valor = valor; this->sig = sig;} void setValor (string valor){ this->valor = valor;} void setSig (Nodo *sig){ this->sig = sig;} string getValor ( ){ return this->valor;} Nodo *getSig ( ){ return this->sig;} };

Una lista es una estructura de datos que nos permite agrupar elementos de una manera organizada. Las listas están compuestas por nodos, estos nodos tienen un dato o valor y un puntero a otro nodo. Un nodo es una estructura que contiene un valor cualquiera y un puntero al siguiente nodo en la lista. LISTAS ENLAZADAS SIMPLES: por ser el punto de partida y fundamentales para poder entender las otras. Una lista enlazada tiene un conjunto de nodos. El último nodo de la lista tiene como siguiente nodo el valor NULL. Entonces las listas enlazadas simples solo pueden ser recorridas en una dirección, apuntando al nodo siguiente, mas no a un nodo anterior.

Gráficamente sería: null Ejemplo de una lista enlazada simple: En lenguaje normal: 55-> 60-> 31-> 5-> 4-> 51-> 9-> 27-> 68-> 62-> NULL En realidad: Nodo-> Dato: 55 Direcion: 0x3d2c00 Siguiente: 0x3d2c80 Nodo-> Dato: 60 Direcion: 0x3d2c80 Siguiente: 0x3d2c90 Nodo-> Dato: 31 Direcion: 0x3d2c90 Siguiente: 0x3d2ca0 Nodo-> Dato: 5 Direcion: 0x3d2ca0 Siguiente: 0x3d2cb0 Nodo-> Dato: 4 Direcion: 0x3d2cb0 Siguiente: 0x3d2cc0 Nodo-> Dato: 51 Direcion: 0x3d2cc0 Siguiente: 0x3d3ab8 Nodo-> Dato: 9 Direcion: 0x3d3ab8 Siguiente: 0x3d3ac8 Nodo-> Dato: 27 Direcion: 0x3d3ac8 Siguiente: 0x3d3ad8 Nodo-> Dato: 68 Direcion: 0x3d3ad8 Siguiente: 0x3d3ae8 Nodo-> Dato: 62 Direcion: 0x3d3ae8 Siguiente: NULL

Obviamente, internamente no existen las palabras nodo, dato, dirección y siguiente, es solo una representación. Como una lista es una estructura de datos dinámica, el tamaño de la misma puede cambiar durante la ejecución del programa. Se puede generar memoria dinámicamente para un array, pero un array es una estructura estática pues su tamaño tiene un limite y así creáramos array dinámicos hay que redimensionar el tamaño si es necesario, lo cual ya implica un costo de volver a generar memoria dinámica. Entonces podemos ver una ventaja de la listas sobre los arrays: No tener que redimensionar la estructura y poder agregar elemento tras elemento indefinidamente. En un vector VEC se puede referenciar una posición de la forma VEC [50] cuando se necesitaba tomar el índice 50 del vector VEC. A esto se le conoce como acceso aleatorio. En el caso de las listas el acceso es secuencial, es decir, para acceder a un elemento del conjunto debemos de recorrer uno por uno los elementos hasta llegar al solicitado. Rápidamente se puede concluir que el tiempo de acceso a los elementos de un array es muchísimo más rápido que en una lista. Esta es una gran desventaja de las listas, por lo que buscar elementos por índice sería muy costoso. Esto no quiere decir que trabajar con arrays sea mejor que con listas. Las listas son muy flexibles y para muchos casos son imprescindibles.

Retomando: null Construcción de la clase lista: recuerde que la lista está conformada por nodos, por ésta razón se deberá tener objetos del tipo nodo para poder operarla:

class Lista { private: Nodo *cabeza; public: Lista ( ){ this->cabeza = NULL;} void setCabeza (Nodo *nodo){ this->cabeza = nodo;} Nodo *getCabeza ( ){ return this->cabeza;} Nodo *getUltimo ( ){ Nodo *aux; aux = this->cabeza; if (aux){ while (aux->getSig ( )!=NULL){ aux = aux->getSig( );} } return aux; };

Nodo *Buscar (string valor){ Nodo *aux; aux = this->cabeza; while (aux){ if (aux->getValor( ) == valor) return (aux); aux = aux->getSig ( ); } return NULL; } void Insertar (string valor){ Nodo *newNodo, *aux; newNodo = new Nodo (valor); aux = this->getUltimo(); if (aux) aux->setSig(newNodo); else this->setCabeza(newNodo); return; }