Estructura de Datos En C++

1. Estructura de Datos En C++ Dr. Romeo SánchezNigenda. E-mail: romeo.sanchez@gmail.com http://yalma.fime.uanl.mx/~romeo/ Oficina: 1er. Piso del CIDET. Oficina con Dr. Oscar Chacón Horas de Tutoría: 10am-11am Martes y Jueves, 3:30pm-4:30pm Miércoles, 2:00pm-4:00pm Viernes. Website: http://yalma.fime.uanl.mx/~romeo/ED/2011/ Sesiones: 48

2. Objetivo General: Conocerá y manejará las estructuras internas de información Temario: • Conceptos Básicos • La Pila • Colas • Recursión • Listas • Árboles • Ordenamiento • Búsqueda • Administración de Almacenamiento Total a calificar: 110 puntos. 40% Tareas 30% Examen Parcial 30% Examen Final 10% Participación

3. Material de apoyo: Estructura de Datos con C y C++. YedidyahLangsam, Moshe J. Augenstein, Aaron M. Tenenbaum, Brooklyn College SegundaEdición, Prentice-Hall. Algorithms. ThirdEdition. Parts 1-4, Fundamentals Data StructuresSortingSearching Robert Sedgewick. Estructura de Datos. Román Martínez, Elda Quiroga. ThomsonLearning. Cualquier libro de Estructura de Datos! Software: Compiladores GCC (GNU CompilerCollection) IDEs (IntegratedDevelopmentEnvironment): http://www.eclipse.org/downloads/ http://kdevelop.org/ http://www.bloodshed.net/devcpp.html

4. 3. Listas • Objetivo: El alumno manejará estructuras de datos lineales y dinámicas, y entenderá las ventajas de utilizarlas para optimizar el uso de espacio en memoria. • Temario: • Definición y conceptos utilizados • Operaciones con listas • Listas circulares • Listas doblemente ligadas • Aplicaciones

5. Listas • Cuáles son las desventajas de usar almacenamiento secuencial para presentar filas y colas? • Una lista vinculada (linkedlist) es una estructura dinámica de nodos de datos los cuales se representan como una secuencia. En su forma más simple, cada nodo se compone: • De un área de datos o información • De una referencia (link) al siguiente nodo en la secuencia • Se puede acceder a la lista vinculada por medio de una variable apuntador externa, que contenga la dirección del primer elemento en la lista. • El último nodo en la lista apunta al valor null para señalar el término de la secuencia. inf inf inf inf sig sig sig sig cabeza

6. Listas • Cada registro de una lista vinculada es a menudo llamado un elemento o nodo • El campo de cada nodo que contiene la dirección al siguiente nodo es usualmente llamado el siguiente link o siguiente puntero (next) • Los campos remanentes contienen los datos, información, o valores • La cabeza (head) de la lista es su primer elemento • La cola (tail) de la lista se puede referir al resto de los elementos después de la cabeza, o al último nodo

7. Listas • Características: • La estructura permite inserción y remoción de elementos eficientemente de cualquier posición en la secuencia • El principal beneficio entonces de una lista sobre arreglos es que sus elementos no necesitan reacomodarse cada vez que se actualiza la lista • Una lista sin nodos se denomina lista vacía, el apuntador externo a la lista es null • Sin embargo, listas simples no permiten acceso randomizado o indexación, por lo que operaciones básicas como obtener el último nodo en la lista o encontrar un nodo puede requerir escanear la mayoría o todos sus elementos

8. Listas: Operaciones básicas • Inserción en la parte delantera de la lista inf inf inf sig sig sig cabeza inf sig & Se obtiene memoria para el nuevo nodo: Se establecen los valores (datos) del nodo: Se establece el link (sig) del nodo al primer elemento en la lista: P Nodo vacío inf sig & P P->sig = cabeza inf sig & P inf inf inf sig sig sig cabeza

9. Operaciones básicas: Inserción Se actualiza el apuntador externo cabeza al nuevo nodo insertado: El valor de P es irrelevante antes y después de la inserción del elemento a la lista: El algoritmo básico de inserción queda entonces: p = creaNodo (); info (p) = 12 //Datosnuevos next (p) = cabeza cabeza = p cabeza = P P inf inf inf inf sig sig sig sig cabeza inf inf inf inf sig sig sig sig cabeza Qué pasa cuando la lista está vacía?

10. Operaciones básicas: Remoción inf inf inf inf sig sig sig sig cabeza Se hace referencia al primer nodo en la lista a través de un apuntador: P = cabeza La cabezade la listadebeapuntar al siguientenodo en la secuencia: cabeza = P->sig Se guardan los valores a retornar en una variable: x = P->info P inf inf inf inf sig sig sig sig cabeza inf sig P inf inf inf sig sig sig cabeza

11. Operaciones básicas: Remoción inf sig P inf inf inf sig sig sig cabeza En estemomento se consideraqueP ya ha sidoremovido de la lista, pues a pesarqueconserva un apuntador a un nodo en la lista, no esposibleacceder a P a través del apuntador externo cabeza. El siguiente paso sería liberar la memoria que P usa: liberaNodo(P) El algoritmo de remoción es básicamente opuesto al de inserción: P = cabeza Cabeza = next(P) X = info(P) liberaNodo(P)

12. Operaciones Básicas: Travesar inf inf inf inf sig sig sig sig cabeza Se obtiene un apuntador al primer elemento (cabeza) de la lista: P = cabeza MIENTRAS que el apuntador no sea nulo (null), se lee el campo de información: X = P -> info Se actualiza la variable apuntador al siguienteelemento en la lista: P = P -> sig P inf inf inf inf sig sig sig sig cabeza inf inf inf inf sig sig sig sig cabeza P P P P … … …

13. Operaciones Básicas: Implementación Definición de un nodo simple usando estructuras en C: structnodo{ intinfo; structnodo * sig; }; typedefstructnodo *NODEPTR; Inicialización de una lista vacía, usando un apuntador externo: NODEPTRcabeza=NULL; Asignación de Memoria NODEPTRcreaNodo(void){ NODEPTR p = (NODEPTR) malloc (sizeof(structnodo)); return(p); } voidliberaNodo(NODEPTR p){ free(p); } Liberación de Memoria

14. Operaciones Básicas: Implementación voidtraversaLista(NODEPTRcabeza){ NODEPTR p = cabeza; while(p!=NULL){ cout<<"Elem: "<<p->info<<endl; p=p->sig; } } inf inf inf inf sig sig sig sig cabeza P P P … P … …

15. Operaciones Básicas: Implementación voidinsertaNodo(NODEPTR * cabeza, int valor){ NODEPTR p =creaNodo(); p->info=valor; p->sig = *cabeza; *cabeza=p; } intborraNodo(NODEPTR * cabeza){ int value = -1; if(*cabeza!=NULL){ NODEPTR p = *cabeza; *cabeza= p->sig; value = p->info; liberaNodo(p); } return value; } NODEPTRcabeza=NULL; insertaNodo(&cabeza,1); traversaLista(cabeza); borraNodo(&cabeza);

16. Operaciones Básicas: Implementación Inserta después de un nodo P: inf inf inf sig sig sig cabeza P voidinsertaDespuesNodo(NODEPTR * P, int valor){ NODEPTR q =creaNodo(); q->info=valor; q->sig=(*P)->sig; (*P)->sig=q; } inf sig q inf sig q inf inf sig sig P inf sig q inf sig inf inf sig sig q P

17. Operaciones Básicas: Implementación Elimina después de un nodo P: inf inf inf sig sig sig cabeza P intdeleteDespuesNodo(NODEPTR * P){ q=(*P)->sig; valor = q->info; (*P)->siq=q->sig; liberaNodo(q); } inf sig inf sig null … P inf sig

18. Listas Implementando Colas inf inf inf sig sig sig cola cabeza P Se consideran dos apuntadores, uno al principio de la lista para remover elementos. El segundo al final de la lista para insertar (FIFO). Pseudocódigo para remover un elemento: remueve(Cola q){ if(!colaVacia(q)){ p = q.cabeza x = info(p) // Almacena 6 en X pararetornarlo q.cabeza= next(P) //cabezaapuntaahora al segundonodo if(q.cabeza==NULL){ q.cola=NULL //Si eliminamos el ultimo, actualiza cola } liberaNodo(p); } }

19. Listas Implementando Colas inf inf inf sig sig sig cola cabeza P Pseudocódigo para insertar un elemento: inserta(Cola q, Elemento x){ p = creaNodo() info(p) = x // Almacena el valor del nuevoelemento en el nodo next(p) = NULL//Nuevo elementoes el último if(q.cola==NULL){ q.cabeza = p; //Cola vacia, entonces p es el primero }else{ next(q.cola) = p //El siguiente de cola apunta al nuevo } q.cola = p //Cola se actualiza al ultimo elemento }

20. Ejemplo: Remueve X elementos inf inf inf inf sig sig sig sig cabeza Pseudocódigo para remover X elementos: q = NULL P = cabeza While(P!=NULL){ If(info(p) == X){ if(q==NULL){ cabeza = next(P) P=cabeza; }else{ p = next(P); deleteDespuesNodo(q) } } else{ q=p; p = next(p) } }

21. ListasCirculares inf inf inf inf sig sig sig sig apunta • Una convención es que el apuntador externo apunte al último nodo en la lista, para así también acceder al primer nodo con el campo sigdel último nodo. • Ejemplo: Pilas como listas circulares, donde el primer nodo es el tope de la Pila. • La pila está vacía si: apunta = NULL • intestaVacia(NODEPTRapunta) { • return (apunta == NULL); • }

22. ListasCirculares: Pilas apunta Último nodo inf inf inf sig sig sig apunta inf inf inf sig inf sig sig sig P • Operación Push • voidpush(NODEPTR * apunta, int x) { • NODEPTR p = creaNodo(); • p->info = x; • if (estaVacia(*apunta)) { • (*apunta) = p; • } else { • p->sig = (*apunta)->sig; • } • (*apunta)->sig = p; • } PUSH

23. ListasCirculares: Pilas Último Nodo Insertado inf inf inf inf sig sig sig sig apunta • Operación Pop • int pop(NODEPTR * apunta) { • if (estaVacia(*apunta)) { • cout << “Pila vacia!" << endl;exit(1); • } • NODEPTR p = (*apunta)->sig; • intx = p->info; • if (p == (*apunta)) • (*apunta) = NULL; • else • (*apunta)->sig = p->sig; • liberaNodo(p); • return x; • }

24. ListasCirculares Último Nodo Insertado Primer Nodo Insertado inf inf inf inf sig sig sig sig apunta • Operación Traversal • voidtraversaPila(NODEPTRapunta) { • NODEPTR p = apunta; • NODEPTR q, ultimo; • if (!estaVacia(apunta)) { • ultimo = q = p->sig; • cout << "Elem: " << q->info << endl; • q = q->sig; • while (q != ultimo) { • cout << "Elem: " << q->info << endl; • q = q->sig; • } • } • }

25. ListasDoblementeVinculadas • Aunquelaslistascircularestienenventajassobrelaslistaslineales, todavía tienen algunas limitaciones importantes: • No se puede recorrer la lista hacia atrás • No puede suprimirse un nodo dado solo un apuntador hacia dicho nodo • En una lista doblemente vinculada, cada nodo posee dos apuntadores, uno a su antecesor y otro a su sucesor • Pueden ser lineales o circulares, y pueden o no tener un nodo de encabezado

26. Ejemplos de ListasDoblementeVinculadas prev prev prev inf sig inf sig inf sig Lista doblemente vinculada prev prev prev inf sig inf sig inf sig Lista circular doblemente vinculada sin encabezado prev prev prev prev inf sig inf sig inf sig inf sig Lista circular doblemente vinculada con encabezado

27. Implementación de ListasDoblementeVinculadas • Definición: • structnodod{ • intinfo; • structnodod *prev, *sig; • }; • typedefstructnodod * NODODOBLEPTR; prev inf sig

28. Implementación de ListasDoblementeVinculadas prev prev prev inf sig inf sig inf sig • Borra el nodo dado: • intdeleteNodoListaDoble(NODODOBLEPTR p){ • if((p)==NULL){ • cout<<"Error en borrado!"<<endl; • exit(1); • } • NODODOBLEPTRl,r; • intx = p->info; • l = p->prev; • r = p->sig; • if(l!=NULL) • l->sig = r; • if(r!=NULL) • r->prev = l; • free(p); • returnx; • }

29. Implementación de ListasDoblementeVinculadas voidinsertaNodoDerecha(NODODOBLEPTRp, int x){ if(p==NULL){ cout<<"Error en insercion!"<<endl; exit(1); } NODODOBLEPTRq,r; q = creaNodoDoble(); q->info = x; r = p->sig; if(r!=NULL){ r->prev = q; } q->sig = r; q->prev = p; p->sig = q; }