ELO320 Estructuras de Datos y Algoritmos Listas Toms Arredondo Vidal

Este material est basado en:

Robert Sedgewick, "Algorithms in C", (third edition), Addison-Wesley, ISBN 0-201-31663-3. 2001 material del curso ELO320 del Prof. Leopoldo Silva material en el sitio http://es.wikipedia.org

5: Listas

5-Listas
5.1 Definiciones y operaciones 5.2 Listas simplemente enlazadas 5.3 Listas doblemente enlazadas 5.4 Listas circulares 5.5 Listas auto organizadas y ordenadas

5: Listas

Definiciones y operaciones
Cada elemento o nodo se representa por una

estructura, cuyos campos pueden ser ledos y escritos a travs de un puntero a la estructura. Suele existir un campo que se denomina clave, que identifica nicamente al nodo. La clave puede ser numrica o alfanumrica. Operaciones posibles sobre listas incluyen:
r r r r r

Recorrer Buscar Seleccionar Insertar Descartar

5: Listas 3

5-Listas
5.1 Definiciones y operaciones 5.2 Listas simplemente enlazadas 5.3 Listas doblemente enlazadas 5.4 Listas circulares 5.5 Listas auto organizadas y ordenadas

5: Listas

Listas simplemente enlazadas

Listas que requieren un solo

enlace (puntero) entre un nodo y su sucesor Elementos se direccionan en tiempo constante O(1), los elementos tienen un costo de acceso de O(n) en el peor caso Las operaciones deben considerar que estas listas pueden estar vacas lo cual requiere un tratamiento especial El uso de un centinela simplifica las operaciones al hacer que todos los nodos sean tratados de forma igual
5: Listas 5

Ejemplo: Lista simplemente enlazada

typedef struct moldenodo { int clave; struct moldenodo *proximo; } nodo, *pnodo; pnodo CreaNodo(int dato) { pnodo pn=NULL; if ( (pn= (pnodo) malloc(sizeof(nodo))) ==NULL) exit(1); else { pn->clave=dato; pn->proximo=NULL; } return(pn); }
5: Listas 6

pnodo lista=NULL;

pnodo listaC = CreaNodo(0);

Ejemplo: Recorrer la lista y contar nodos

int LargoLista(pnodo p) { int numeroelementos = 0; while (p != NULL) { numeroelementos ++; p = p ->proximo; //recorre la lista } return (numeroelementos); } int LargoLista(pnodo p) { int numeroelementos = 0; for ( ; p != NULL; p=p->proximo) numeroelementos ++; return (numeroelementos); }
5: Listas 7

Ejemplo: Buscar un nodo

pnodo Buscar(pnodo p, int valor) { while (p != NULL) { if (p->clave== valor) return (p); //lo encontr else p = p ->proximo; //recorrer: O(n) } return (p); //retorna NULL si no lo encontr. } Como usar esta funcin? if ( (q= Buscar(listaC->proximo, 5)) == NULL) { /* no encontr nodo con clave = 5*/ } else { /* lo encontr. ..*/ }
5: Listas 8

pnodo q; if ( (q= Buscar(lista, 5)) == NULL) { /* no encontr nodo con clave = 5*/ } else { /* lo encontr. ..*/ }

Ejemplo: Seleccionar un valor extremo (mnimo)

pnodo SeleccionarMinimo(pnodo p) { int min; else { min=p->clave; //Inicia min t=p; p=p->proximo; } while (p != NULL) { if (p->clave <min ) { min=p->clave; t=p; } p = p ->proximo; //recorre la lista. O(n) } return (t); }
5: Listas 9

pnodo t;

if (p==NULL) return (NULL);

Ejemplo: Buscar el ltimo nodo

pnodo ApuntarAlFinal(pnodo p) // como programar? { pnodo t; if (p==NULL) { return (NULL); } else while (p != NULL) { t=p; p = p ->proximo; //recorre la lista. O(n) } return (t); }
5: Listas 10

Listas: insercin
Hay dos variables de tipo puntero a

nodo: p apunta a un nodo de una lista y n apunta a un nodo correctamente inicializado (e.g. retorno de CreaNodo). El nodo apuntado por n puede ser insertado despus del nodo apuntado por p usando: n->proximo = p->proximo; Para completar la lista se usa: p->proximo = n; Como seria el diagrama final?
5: Listas 11

Ejemplo: insertar despus

Ejemplo de uso:

Si el argumento posicin toma valor NULL, se producir un error, por eso se verifica su existencia,
pnodo nuevo)

pnodo lista=NULL; //inicializar lista pnodo pos=NULL; lista=InsDespues(pos, CreaNodo(1)); pos =Buscar(lista, 1); InsDespues(pos, CreaNodo(2)); pos =Buscar(lista, 2); InsDespues(pos, CreaNodo(3)); pos =Buscar(lista, 2); InsDespues(pos, CreaNodo(4));

pnodo InsDespues( pnodo posicin, { if (nuevo == NULL) return (NULL); if (posicion != NULL) { nuevo->proximo = posicion->proximo; posicion->proximo=nuevo; return (posicion); } return(nuevo); }

5: Listas

12

Listas: insercin antes

Si se desea insertar antes de la posicin p;

se requiere una variable temporal para efectuar el intercambio (i.e. temp) : pnodo p = NULL; //inicializar lista p = InsDespues(p,CreaNodo(1)); InsDespues(p,CreaNodo(2)); pnodo n = CreaNodo(3); // Como es el diagrama? int temp; n->proximo = p->proximo; p->proximo = n; temp=p->clave; p->clave=n->clave; n->clave=temp; // Como es el diagrama final?

p 1 n 3 2

5: Listas

13

Listas: insercin al final

Si se desea insertar al final:

pnodo InsertaNodoalFinal(pnodo posicion, int dato) { pnodo temp=posicion; if (temp != NULL) { while (temp->proximo !=NULL) temp=temp->proximo; //O(n) temp->proximo=CreaNodo(dato); return (temp->proximo); //retorna NULL si no se pudo crear } else return (CreaNodo(dato)); } // Ejemplo uso?
5: Listas 14

Insercin: cabeza y cola

Usando variables globales

cabeza y cola: static pnodo cabeza=NULL; static pnodo cola=NULL;

pnodo insertainicio(int clave) { pnodo t=CreaNodo(clave); if(cabeza==NULL) cola=t; t->proximo=cabeza; cabeza=t; //O(1) return(t); }

Insertafinal( )?

pnodo insertafinal(int clave) { pnodo t =CreaNodo(clave); if(cola==NULL) { cola=cabeza=t;} else { cola->proximo=t; cola=t;} //O(1) 5: Listas return(t); }

15

Insercin con referencias

Usando referencias: Uso?:

void ins_nodo_ref(pnodo *p, pnodo t) { if (*p==NULL) *p=t; //inserta en lista vaca. else { t->proximo=*p; //lee var. externa. *p=t; //escribe en var. externa. } }

pnodo lista1=NULL; Insertanodo_ref(&lista1, CreaNodo(4)); Insertanodo_ref(&lista1, CreaNodo(3)); Insertanodo_ref(&lista1, CreaNodo(2)); Insertanodo_ref(&lista1, CreaNodo(1));

5: Listas

16

Listas: descarte
La variable p apunta al nodo

anterior al que se desea descartar, t apunta al nodo que se desea desligar de la lista despus de ejecutada la accin: t=p->proximo; Para mantener la lista ligada: p->proximo = t->proximo;
Despus se libera el espacio del

nodo descartado: free(t); t=NULL;

5: Listas 17

5-Listas
5.1 Definiciones y operaciones 5.2 Listas simplemente enlazadas 5.3 Listas doblemente enlazadas 5.4 Listas circulares 5.5 Listas auto organizadas y ordenadas

5: Listas

18

Listas doblemente enlazadas

Estas listas requieren dos

enlaces (punteros) entre un nodo, su sucesor y su antecesor: typedef struct moldecelda { int clave; struct moldecelda *nx; //next struct struct modecelda *pr; // previous } nodo, *pnodo;

5: Listas

19

Listas doblemente enlazadas: insertar despus

Diagramas muestran las variables

antes de insertar el nodo apuntado por q a la lista dada por p. Como seria el cdigo para insertar? q->nx = p->nx; q->pr = p; p->nx = q ; q->nx->pr = q; Como seria descartar el nodo q? q->pr->nx = q->nx; q->nx->pr = q->pr; free(q);
5: Listas 20

Listas doblemente enlazadas: condiciones

Las operaciones de insertar, buscar y descartar deben

considerar las condiciones en los bordes, y que la lista pueda estar vaca. Una forma usual de tratar simplificadamente las condiciones de borde, es definir un nodo vaco, denominado cabecera o centinela.

5: Listas

21

5-Listas
5.1 Definiciones y operaciones 5.2 Listas simplemente enlazadas 5.3 Listas doblemente enlazadas 5.4 Listas circulares 5.5 Listas auto organizadas y ordenadas

5: Listas

22

Listas circulares
En listas simplemente enlazadas, sin o con cabecera,

puede escogerse que el ltimo nodo apunte al primero, con esto se logra que el primer nodo pueda ser cualquier nodo de la lista.

La insercin al inicio, en el caso de la figura debe

tratarse de manera especial, con costo O(n), para que el ltimo nodo apunte al nuevo primero. Si la lista es con centinela, y si el ltimo apunta al centinela, no es necesario introducir cdigo adicional.
5: Listas 23

5-Listas
5.1 Definiciones y operaciones 5.2 Listas simplemente enlazadas 5.3 Listas doblemente enlazadas 5.4 Listas circulares 5.5 Listas auto organizadas, ordenadas

5: Listas

24

Listas auto organizadas y ordenadas

En listas auto organizadas la operacin buscar

mueve a la primera posicin el elemento encontrado.

r

De esta manera los elementos ms buscados van quedando cerca del inicio.

En listas ordenadas se mantienen los nodos

ordenados segn el orden de las claves. Se puede tratar las listas en base a arreglos. Pudiendo ser stos: arreglos de nodos, en los cuales se emplean punteros; o bien arreglos que contienen la informacin de vnculos en base a cursores que almacenan ndices.
5: Listas 25