LISTAS ESPECIALES

Estructuras de Datos

C) Referencia_Nodo EliminarPrimero(L) Referencia_Nodo EliminarUltimo(L) EliminarNodo(L. C) InsertarNodoAntesDe(L. C) InsertarNodoFinal(L. la posición P y la información C     EliminarLista(L) Referencia_Nodo ConsultarPrimero(L) Referencia_Nodo ConsultarUltimo(L) bool EstaVacia(L) bool EstaLlena(L) InsertarNodoInicio(L. P) Recorrer(L) . P) Referencia_Nodo BuscarNodo(L.LISTAS: OPERACIONES BASICAS CrearLista()            Dada la Lista L. P. C) Referencia_Nodo PosAnterior(L.

excepto el primero Un sucesor. hacia el siguiente y hacia el anterior <lde> ::= <comienzo> + {<nodo>}+<ultimo> <comienzo> :: = <enlace> <ultimo> :: = <enlace> <enlace> ::= (<<referencia_nodo>> | NULL) <nodo> ::= <predecesor>+<contenido>+<sucesor> <predecesor> ::= <enlace> <sucesor> ::= <enlace> < contenido > ::= <<dato>>{<<dato>>} .TDA: LISTAS DOBLEMENTE ENLAZADAS    En las listas enlazadas solo se avanza en un sentido En las doblemente. tiene dos. excepto el ultimo  Cada nodo ya no tiene un solo enlace. En estas listas cada nodo tiene   Un predecesor. se puede avanzar hacia la derecha o hacia la izq.

. NULL LDE_Nodo *last. Cuando la lista esta vacia. typedef struct { son iguales a LDE_Nodo *header.LDE: IMPLEMENTACION header 10 5 8 25 2 last 31 DA I DS typedef struct LDE_Nodo { Generico G. struct LDE_nodo *sig. }LDE. header y last. } LDE_nodo . struct LDE_nodo *ant.

if(LDE_EstaVacia(&L)) L->header = L->last = nuevo. } return TRUE. } . L->last->sig = nuevo.INSERTAR NODOS nuevo->ant = last header header nuevo 15 header header->ant = nuevo 10 5 21 12 17 last 6 nuevo->sig = header last = nuevo last nuevo 15 last->sig = nuevo bool LDE_InsertarNodoFin (LDE *L. LDE_nodo *nuevo){ if(!nuevo) return FALSE. L->header->ant = nuevo. L->last = Nuevo. L->header = nuevo. LDE_nodo *nuevo){ header = nuevo bool LDE_InsertarNodoInicio(LDE *L. else{ nuevo->ant = L->last. if(LDE_EstaVacia(*L)) L->header = L->last = nuevo. } return FALSE. else{ nuevo->sig = L->header. } if(!nuevo) return FALSE.

p->sgt = nuevo. } return TRUE.nuevo). LDE_nodo *nuevo){ if (!p || !LDE_Existe(*L. } 15 nuevo nuevo->sig = p->sig.P)) return FALSE. LDE_nodo *p. p->sig = nuevo . nuevo->sgt->ant = nuevo.INSERTAR ENTRE header 10 5 p 21 last nuevo->sig->ant = nuevo 12 17 6 nuevo->ant = p bool LDE_InsertarNodo(LDE *L. nuevo->sgt = p->sgt. else { if(!nuevo) return FALSE. nuevo->ant = p. if(LDE_EstaVacia(*L) || p==L->last) LDE_InsertarNodoFin(L.

ELIMINAR NODOS header 10 5 p 21 P->sig->ant = p->ant last 12 17 6 free(p). if(p==L->header){ tmp = L->header.P). p->sig->ant = p->ant. return(LDE_SacarNodoFin(L)). } if (!p) return NULL. L->last = L->last->ant.G. } } .P)) return NULL. Generico_Comparar fn){ return(tmp).) return(tmp). L->header = L->header->sig. return p. return(LDE_SacarNodoInicio(L)). } LDE_Nodo *p . fn). } else if (P==L->last){ LDE_nodo *LDE_EliminarxInfo(LDE *L. else { p->ant->sig = p->sig. p = LDE_Buscar(L. p->ant->sig = p->sig. LDE_nodo *p){ if(!p || !LDE_Existe(L. L->last->sig = NULL. LDE_nodo *LDE_EliminarxPos (LDE *L. tmp= L->last. if(EstaVacia(L)) return. Generico G. L->header->ant = NULL. return(LDE_EliminarxPos(L.

pasar al primero  last->siguiente = header last->sig 10 5 8 25 2 last 31 .LISTAS CIRCULARES  El avance en las listas enlazadas es   Solo a la derecha(siguiente) Limitado hasta el ultimo nodo  Hay ocasiones en las que se desearia.   Poder avanzar ilimitadamente Del ultimo nodo.

}LCE_nodo. struct LCE_nodo *sig. pues  last ->siguiente es igual a header typedef struct LCE_nodo{ Generico G. .EL TDA LISTA CIRCULAR  No es necesario mantener un control de:   Primero y ultimo Solo con el ultimo ya se tiene todo. typedef LCE_nodo *LCE.

nuevo->sig = nuevo. nuevo->G = G. nuevo = malloc(sizeof(LCE_Nodo)). return nuevo. } I DS .CREAR NODO  Para crear un nodo valido LCE_Nodo * LCE_Nodo_Crear(Generico G){ LCE_Nodo *nuevo.

p = L. Generico G. p p p p 5 p 8 p p 25 p p 2 last 31 } last->sig 10 . Generico_Comparar fn){ LCE_nodo *p. do{ if(fn(p->G. G) == 0) return(p). if(LCE_EstaVacia(*L)) return NULL. }while(p!= L). Busco 13 25 p = p->sig. p return(NULL).LOCALIZA LCE_nodo *LC_Buscar(LCE *L.

ANTERIOR  Es buscar el anterior a un nodo dado LCE_Nodo *LCE_Anterior(LCE *L. }while(q!=L). LCE_nodo *p){ LCE_Nodo *q. if(LCE_EstaVacia(L) || p== NULL) LCE_Anterior = NULL. } . return(NULL). q = q->sig. do{ if(q->sig == p) return(q). q = L.

} bool LCE_InsertarNodoFin(LCE *L. } L = nuevo. LCE_Nodo *nuevo){ if(nuevo == NULL) return FALSE. L->sig = nuevo. else{ nuevo->sig = L->sig. } return TRUE. last = nuevo return TRUE. } . if(LCE_EstaVacia(*L)) L = nuevo.INSERTAR INICIO Y FIN last->sig 10 5 8 nuevo->sig = last->sig last nuevo last->sig = nuevo 25 2 last 31 10 bool LCE_InsertarNodoInicio(LCE *L. L->sig = nuevo. else{ nuevo->sigt = L->sig. if(LCE_EstaVacia(L)) L = nuevo. LCE_nodo *nuevo ){ if(nuevo == NULL) return FALSE.

LCE_Nodo *nuevo){ if(P == NULL || !LCE_Existe(*L.P)) return FALSE. else { nuevo->sig = P->sig. P->sig = Nuevo. } return TRUE.INSERTAR EN MEDIO bool LCE_Insertar(LCE *L. LCE_Nodo *P. } .nuevo). if(LCE_EstaVacia(*L) || p==L) LCE_InsertarNodoFin(L.

if(LCE_EstaVacia(*L)) return 0. *ant. if(L ==L->sig){ L = NULL. if(p == NULL) return 0.ELIMINA LCE_Nodo * LCE_EliminarxInfo(LCE *L.fn). Generico_Comparacion fn){ LCE_Nodo *p . return(LCE_EliminarxPos(L. if(p == NULL || !LCE_Existe(*L. } else { ant = LCE_Anterior(*L. L = ant.p)). } } . eliminado = L ant = LCE_Anterior(L.I. } LCE_Nodo *LCE_EliminarxPos(LCE *L. return(L).L). ant->sig = p->sig. LCE_nodo *p){ LCE_Nodo *elminado.p). Generico G. p = LCE_Buscar(*L.p)) return NULL. return(p). } else if (p==L){ return(LCE_SacarNodoFin(L)). return(eleminado). ant->sig = L->sig.

LISTAS CIRCULARES DOBLEMENTE ENLAZADAS   Es una implementacion de listas circulares  Con nodos que tienen dos punteros Sentido del avance del reloj y En sentido contrario Asi se recorre la lista en el    Seguimos llevando un control solo del ultimo nodo de la lista last 31 10 5 8 25 2 .

Hacia atras void LCDE_Recorre_R(LCDE L. Enla. } } . pos = L. if(pos == L) break.RECORRER LISTA  Escribir una operación Recorre_R que recorre una lista cir. if(!LCDE_EstaVacia(L)) return. Dobl. while(TRUE){ pos = pos->ant. fn(pos->G). Generico_Imprimir fn){ LCDE_nodo *pos.