1 ListaUna Lista se define como una serie de N elementos E 1, E 2,..., E N, ordenados de manera consecutiva, es decir, el elemento E k (que se denomina.

Presentación del tema: "1 ListaUna Lista se define como una serie de N elementos E 1, E 2,..., E N, ordenados de manera consecutiva, es decir, el elemento E k (que se denomina."— Transcripción de la presentación:

1 1 ListaUna Lista se define como una serie de N elementos E 1, E 2,..., E N, ordenados de manera consecutiva, es decir, el elemento E k (que se denomina elemento k-ésimo) es previo al elemento E k+1. Si la lista contiene 0 elementos se denomina como lista vacía. La forma en que la lista esta ordenada fuede basarse en ciertas condiciones, como por ejemplo ordenadas en forma ascendente. Las operaciones que se pueden realizar en la lista son: EstaVacia(): devuelve verdadero si la lista esta vacía, falso en caso contrario. Insertar(x, k): inserta el elemento x en la k-ésima posición de la lista. Buscar(x): devuelve la posición en la lista del elemento x. BuscarK(k): devuelve el k-ésimo elemento de la lista. Eliminar(x): elimina de la lista el elemento x. Una manera simple de implementar una lista es utilizando un arreglo, pero la inserción y borrado de elementos es ineficientes, ya que es necesario mover todos los elementos para hacer espacio o para ocupar un espacio desocupado. Cuando se necesitan estructuras que puedan cambiar de tamaño durante la ejecución del programa, se podrian crear arrays dinamicos; pero una vez creados, su tamaño también será fijo.

2 2 Una implementación más eficiente del TDA se logra utilizando listas enlazadas, donde su tamaño puede cambiar durante la ejecución del programa. NodosElementos Las Listas Enlazadas están compuestas de otras pequeñas estructuras: Nodos o Elementos, que agrupan los datos con los que se trabajaran, y además uno o más punteros autoreferenciales, es decir, punteros a objetos del mismo tipo nodo. Una estructura básica de un nodo para crear listas de datos seria: Una Lista Enlazada es una estructura vacía o un elemento de información y enlace hacia una lista (varios nodos enlazados). Información Nodo SigteNODO class NODO { //Información: //Atributos y Métodos NODO *NodoSigte; } Representación graficaImplementación en C++

3 3 Listas abiertas:Listas abiertas: cada elemento sólo dispone de un puntero, que apuntará al siguiente elemento de la lista o valdrá NULL si es el último elemento. Pilas:Pilas: son un tipo especial de lista, conocidas como listas LIFO (Last In, First Out: el último en entrar es el primero en salir). Los elementos se "amontonan" o apilan, de modo que sólo el elemento que está encima de la pila puede ser leído, y sólo pueden añadirse elementos encima de la pila. Colas:Colas: otro tipo de listas, conocidas como listas FIFO (First In, First Out: El primero en entrar es el primero en salir). Los elementos se almacenan en fila, pero sólo pueden añadirse por un extremo y leerse por el otro. Listas circulares: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: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. Árboles:Árboles: cada elemento dispone de dos o más punteros, pero las referencias nunca son a elementos anteriores, de modo que la estructura se ramifica y crece igual que un árbol. Árboles binarios:Árboles binarios: son árboles donde cada nodo sólo puede apuntar a dos nodos. Grafos:Grafos: es el siguiente nivel de complejidad, podemos considerar estas estructuras como árboles no jerarquizados.

4 4 LISTA Cabecera Actual Datos Sgte Datos Sgte Datos Sgte Datos Sgte NULL class NODO { //Información: //Atributos y Métodos NODO *Sigte; } class LISTA { NODO *Cabecera; NODO *Actual; Public: EstaVacia(); Insertar(x, k); Buscar(x); BuscarK(k); Eliminar(x); Avanzar(); /*A vanza Actual al siguiente nodo de la lista.*/ Obtener(); /*Retorna el elemento del nodo en donde se encuentra Actual*/ }

5 5 REPRESENTACIÓN DE POLINOMIOS. Las listas se utilizan para almacenar los coeficientes diferentes de cero del polinomio, junto al exponente. Así, por ejemplo, dado el polinomio: P(x) = 3X 4 + 0.5X 3 + 6X - 4 Su representación mediante listas, sería la mostrada en la figura: El campo información de cada nodo de la lista contendrá dos campos: el campo COEFICIENTE y el campo EXPONENTE.

6 6 class Nodo { int Valor; Nodo *Sigte; public: Nodo(int v); Nodo(int v, Nodo *sig); int ConsultarValor(); Nodo* ConsultarSigte(); void AsignarASigte(Nodo *Nuevo); }; class Lista { Nodo *Cabeza, *Actual; public: Lista(); ~Lista(); bool ListaVacia(); void MoverActual(); void Mostrar(); void Inicio(); void Ultimo(); bool ConsultarActual(); int ValorActual(); void Insertar(int v); void Borrar(int v); }; LINEA 0..* 2 NODO Manejo de nodos

7 7 Nodo::Nodo (int v) { Valor = v; Sigte = NULL; } Nodo::Nodo (int v, Nodo *sig) { Valor = v; Sigte = sig; } int Nodo::ConsultarValor() { return Valor; } Nodo* Nodo::ConsultarSigte() { return Sigte; } void Nodo::AsignarASigte(Nodo *Nuevo) { Sigte = Nuevo; } Lista::Lista() { Cabeza = Actual = NULL; } Lista::~Lista() { Nodo *aux; while(Cabeza != NULL) { aux = Cabeza; Cabeza = Cabeza->ConsultarSigte(); delete aux; } Actual = NULL; } bool Lista::ListaVacia() { return Cabeza == NULL; } void Lista::MoverActual() { if (Actual != NULL) Actual = Actual->ConsultarSigte(); } void Lista::Inicio() { Actual = Cabeza; } void Lista::Ultimo() { Inicio(); if (!ListaVacia()) while (Actual->ConsultarSigte()) MoverActual(); } bool Lista::ConsultarActual() { return Actual != NULL; } int Lista::ValorActual() { return Actual->ConsultarValor(); }

8 8 void Lista::Insertar (int v) { Nodo *Anterior, *aux; //Si la Lista está vacía if( ListaVacia()) { /*Asignamos a Lista un nuevo nodo de Valor v y cuyo siguiente elemento es la lista Actual*/ Cabeza = new Nodo(v, Cabeza); } else { // Buscar el Nodo de Valor menor a v Anterior = Cabeza; /*avanzamos hasta el último elemento o hasta que el Sigte tenga un Valor mayor que v */ while( Anterior->ConsultarSigte()) Anterior = Anterior->ConsultarSigte(); /*Creamos un nuevo Nodo después del Nodo Anterior, y cuyo Sigte es el Sigte del Anterior*/ aux = Anterior->ConsultarSigte(); aux = new Nodo(v, Anterior->ConsultarSigte()); Anterior->AsignarASigte(aux); }

9 9 void Lista::Borrar (int v) { Nodo *Anterior, *Ref, *aux; Ref = Cabeza; Anterior = NULL; while ((Ref!= NULL) && (Ref->ConsultarValor() != v)) { Anterior = Ref; Ref = Ref->ConsultarSigte(); } if ( (Ref != NULL) && (Ref->ConsultarValor() == v) ) { // Borrar el Nodo if (!Anterior) // Primer elemento Cabeza = Ref->ConsultarSigte(); else // un elemento cualquiera { aux = Anterior->ConsultarSigte(); aux = Ref->ConsultarSigte(); Anterior->AsignarASigte(aux); } delete Ref; } void Lista::Mostrar() { Nodo *aux; aux = Cabeza; while (aux!=NULL) { cout ConsultarValor(); aux = aux->ConsultarSigte(); if (aux!= NULL) cout "; } cout << endl; }

10 10 int PedirDato() { int V; cout >V; return V; } int main() { Lista L; L.Insertar(PedirDato()); L.Mostrar(); cout<<"Lista de elementos:"<< endl; L.Inicio(); while(L.ConsultarActual()) { cout << L.ValorActual() << endl; L.MoverActual(); } L.Inicio(); cout<<"Cabeza: "<<L.ValorActual(); cout<<endl; L.Ultimo(); cout<<"Ultimo: "<<L.ValorActual(); cout<<endl; L.Borrar(PedirDato()); cout<<"Elementos No borrados:"; cout<<endl; L.Mostrar(); return 0; }

11 11 Ingrese un valor: 20 Ingrese un valor: 10 Ingrese un valor: 40 Ingrese un valor: 30 10 -> 20 -> 30 -> 40 Lista de elementos: 10 20 30 40 Cabeza: 10 Ultimo: 40 Ingrese un valor: 10 Ingrese un valor: 15 Ingrese un valor: 45 Ingrese un valor: 30 Ingrese un valor: 40 Elementos No borrados: 20 Salida: