Tema: LISTAS DOBLEMENTE

ENLAZADAS
Contenido
Listas Doblemente Enlazadas.
Operaciones con Listas doblemente enlazadas.
Implementacin en C++
LISTAS DOBLEMENTE ENLAZADAS
Una lista doblemente enlazada es una coleccin de
nodos, en el cual cada uno de ellos tiene dos
apuntadores, uno apuntando a su predecesor(ANT),
y otro apuntando a su sucesor(SIG). Por medio de
estos punteros se podr entonces avanzar o
retroceder a travs de la lista doblemente ligada que
almacena nmeros enteros.
Para tener un fcil acceso a la informacin de la lista
es recomendable usar dos apuntadores Primero y
Ultimo, que apunten al principio y al final de sta,
respectivamente.
IMPLEMENTACIN DE LA CLASE NODO
Cuando la lista
esta vaca,
primero y
ultimo, son
iguales a NULL
ultimo Primero
10 5 8 25 2 31
class nodo{
private:
int info;
nodo *sig;
nodo *ant;
public:
nodo(int pDato)
{
this->info=pDato;
this->sig=NULL;
this->ant=NULL;
}
};
nodo
info
sig
ant
class ListaDoblementeEnlazada {
private:
nodo *primero;
nodo *ultimo;
public:
int talla;
ListaDoblementeEnlazada() {}
bool lista_esta_vacia(){}
void insertar_al_inicio(int pValor){}
void insertar_al_final(int pValor){}
void mostrar_lista_directo(){}
void mostrar_lista_inverso(){}
void insertar_nodo_antes_de_x(int pValor, int valBus ){}
void insertar_nodo_despues_de_x(int pValor, int valBus ){}
void eliminar_primer_nodo(){}
void eliminar_ultimo_nodo(){}
void eliminar_nodo_x(int){}
}
POSIBLE IMPLEMENTACIN LA CLASE LISTA
DOBLEMENTE ENLAZADA
INICIALIZACIN DE LA LISTA DOBLEMENTE
ENLAZADA
: CONSTRUCTOR
Un constructor siempre sirve para dar valor a
los atributos del objeto.
Los atributos primero y ultimo son
referencias al primer y ultimo nodo de la lista,
respectivamente. Estos punteros nos
permiten recorrer la lista en ambas
direcciones.
Inicialmente, la lista esta vaca y no hay
ningn nodo inicial. Por ello, primero y
ultimo apuntan a NULL.

listaDoblementeEnlazada(){
this->primero=NULL;
this->ultimo=NULL;
this->talla=0;
}
OPERACIONES EN LISTAS DOBLEMENTE
ENLAZADAS
Las operaciones que pueden efectuarse en una
lista doblemente enlazada son:
Recorrido de la lista
Insercin de una lista
Borrado de un elemento
Bsqueda de un elemento
RECORRIDO DE UNA LISTA SIMPLEMENTE
LIGADA
Al tener cada nodo una doble liga de enlace, la
lista se puede recorrer tanto del inicio al final,
mediante las ligas SIGUIENTES, como en
sentido inverso; es decir del final al principio, con
las ligas ANTERIORES. Cualquiera que sea la
direccin del recorrido, el algoritmo es similar al
que se present en las listas simplemente
ligadas.
void recorrido_directo()
{
nodo *temp=this->primero;
if(lista_esta_vacia())
{
cout<<"Lista vacia!";
}
else{
while(temp!=NULL){
temp=temp->sig;
}
}
}
RECORRIDO DIRECTO
void recorrido_inverso(){
nodo *temp=this->ultimo;
if(lista_esta_vacia()){
cout<<"Lista vacia!";
}
else{
while(temp!=NULL){
temp=temp->ant;
}
}
}
RECORRIDO INVERSO
INSERCIN EN LISTAS DOBLEMENTE
LIGADAS
La operacin de insercin en las listas doblemente
ligadas consiste en agregar un nuevo nodo a la
lista y establecer los apuntadores
correspondientes. Sin embargo, dependiendo de
la posicin en la que se deba insertar el nodo, se
pueden presentar diferentes casos, como los que
se sealan a continuacin:
Insertar un nodo al inicio de la lista
Insertar un nodo al final de la lista
Insertar un nodo antes que otro cuya informacin es X
Insertar un nodo despus que otro cuya informacin es X
INSERTAR UN NODO AL INICIO DE LA LISTA
DOBLEMENTE LIGADA
Primero
ANT=NULL
Y
SIG
ANT
Z
SIG=NULL
ltimo
nodo *nuevo=new nodo(X);
1
Nuevo
ANT=NULL
X
SIG=NULL
1
Insertar un nodo al inicio de la lista
nodo *nuevo=new nodo(X);
1
nuevo->sig=this->primero; 2
this->primero->ant=nuevo;
3
2
Nuevo
ANT=NULL
X
SIG=NULL
1
3
this->primero=nuevo;
4
4
Primero
ANT=NULL
Y
SIG
ANT
Z
SIG=NULL
ltimo
void insertar_al_inicio(int pValor){
nodo *nuevo=new nodo(pValor);
if(lista_esta_vacia()){
this->primero=nuevo;
this->ultimo=nuevo;
}
else{
nuevo->sig=this->primero;
this->primero->ant=nuevo;
this->primero=nuevo;
}
}
INSERTAR UN NODO AL INICIO DE LA LISTA:
CDIGO
INSERTAR UN NODO AL FINAL DE LA LISTA
ANT=NULL
Y
SIG
ltimo
Primero
ANT
Z
SIG
ANT
W
SIG=NULL
ltimo
ANT
Z
SIG
ANT
W
SIG=NULL
nodo *nuevo=new nodo(X);
Nuevo
ANT=NULL
X
SIG=NULL
1
1
this->ultimo=nuevo;
nuevo->ant=this->ultimo;
this->ultimo->sig=nuevo;
2
2
3
4
3
4
void insertar_al_final(int pValor){
nodo *nuevo=new nodo(pValor);
if(lista_esta_vacia()){
this->primero=nuevo;
this->ultimo=nuevo;
}
else{
nuevo->ant=this->ultimo;
this->ultimo->sig=nuevo;
this->ultimo=nuevo;
}
}
INSERTAR UN NODO AL FINAL DE LA LISTA : Cdigo
ACTIVIDAD
Implementar los algoritmos necesarios
para realizar los procesos siguientes
en listas doblemente enlazadas.
Insertar un nodo antes que otro
cuya informacin es X
Insertar un nodo despus que otro
cuya informacin es X
void mostrar_lista_directo(){
nodo *temp=this->primero;
if(lista_esta_vacia()){
cout<<"Lista vacia!";
}
else{
while(temp!=NULL){
cout<<temp->ant<<"<--"<<temp->info<<"-->"<<temp->sig<<endl;
temp=temp->sig;
}
}
}
MOSTRAR LOS ELEMENTOS DE LA LISTA:DIRECTO
void mostrar_lista_inverso(){
nodo *temp=this->ultimo;
if(lista_esta_vacia()){
cout<<"Lista vacia!";
}
else{
while(temp!=NULL){
cout<<temp->ant<<"<--"<<temp->info<<"-->"<<temp->sig<<endl;
temp=temp->ant;
}
}
}
MOSTRAR LOS ELEMENTOS DE LA LISTA:INVERSO
ELIMINACIN EN LAS LISTAS DOBLEMENTE
LIGADAS
La operacin de eliminacin de un nodo en una lista
doblemente ligada, al igual que en el caso de las
listas simplemente ligadas, consiste en eliminar un
elemento de la lista, redefiniendo los apuntadores
correspondientes y liberando el espacio de memoria
ocupado por el nodo. En la eliminacin se pueden
presentar diferentes casos, aunque algunos de ellos
son simtricos, ya que cada nodo tiene apuntadores
hacia adelante y hacia atrs.
Se pueden dar los siguientes casos:

Eliminar el primer nodo
Eliminar el ultimo nodo
Eliminar un nodo con informacin X
Eliminar el nodo anterior al nodo con
informacin X
Eliminar el nodo posterior al nodo con
informacin X

Eliminar el primer nodo
void eliminar_primer_nodo(){
nodo* temp=this->primero;
if(lista_esta_vacia()){
cout<<"Lista Vacia!";
}
else{
if(temp->sig!=NULL){//validamos si el nodo a borrar no es el nico nodo
this->primero=temp->sig;
this->primero->ant=NULL;
delete temp;
}
else{
this->primero=NULL;
this->ultimo=NULL;
}
}
}
Eliminar el ltimo nodo
void eliminar_ultimo_nodo(){
nodo* temp=this->ultimo;
if(lista_esta_vacia()){
cout<<"Lista Vacia!";
}
else{
if(temp->ant!=NULL){//validamos si el nodo a borrar no es el unico nodo
this->ultimo=temp->ant;
this->ultimo->sig=NULL;
delete temp;
}
else{
this->primero=NULL;
this->ultimo=NULL;
}
}
}
ACTIVIDAD
Implementar los algoritmos necesarios
para realizar los siguientes procesos:
Eliminar un nodo con informacin X
Eliminar el nodo anterior al nodo con informacin X
Eliminar el nodo posterior al nodo con informacin X