6. Listas Dobles.

Listas Dobles.

Las listas enlazadas dobles incorporan UN PUNTERO MAS. Con dos punteros formado parte de la estructura un puntero se utiliza para apuntas a la próxima instancia ( como en la lista Enlazada Simple) y el orto para apuntar la instancia anterior.

Esto nos permite recorrer en ambas direcciones la lista, enlazada DOBLE en este caso.

Observación:

En los extremos se deberá indicar con NULL 

  • el puntero que apuntan a la siguiente instancia en la última instancia
  • el puntero que apunta a la instancia anterior en la primer instancia
  • Se pueden  recorrer en los DOS sentidos!!


Código:

#include <iostream>
using namespace std;
struct datos  //Estructura Global
{
int Tel;
int legajo
struct datos *p_siguiente; //puntero a la proxima instancia
struct datos *p_anterior;// puntero a la instancia anterior.
};
void cargar(datos *);//Ver que al agrumento datos se declaró antes
void agregar(datos *);//Ver que al agrumento datos se declaró antes
int main()
{   
  datos  *p, *puntero_inicio= new datos; //creo un puntero temporal p y 
  //otro al inicio y solicito la 1er instancia en main()

  puntero_inicio->p_anterior=NULL;
  cargar(puntero_inicio); //cargo la 1er instancia
  //Cargo segunda instancia
  agregar(puntero_inicio); //siempre paso el puntero a la 1er instancia
  //Cargo tercer instancia
  agregar(puntero_inicio); //siempre paso el puntero a la 1er instancia
//Muestro la lista enlazada doble de tres instancias
  p=puntero_inicio; //inicializo puntero temporal
  bool primera=true;// variable de uso temporal
  do
     {
     if (primera)primera=false; //la primera vez no apunto a la proxima instancia
     else p=p->p_siguiente;//si no es la primera vez apunto a la proxima instancia

     cout<<p<<"-"<< p->legajo << "-" << p->Tel << "-" <<"siguiente: "
     << p->p_siguiente << "-" <<"anterior: "<< p->p_anterior << endl;
     }while (p->p_siguiente != 0);
  delete []puntero_inicio;
  return 0;
}


void cargar(datos *puntero)//ver que puntero es una COPIA de puntero_inicio
{ 
    cout << "ingrese telefono" << endl;
    cin >> puntero->Tel; //cargo los datos
    cout << "ingrese legajo" << endl;
    cin >> puntero->legajo;
    puntero->p_siguiente = NULL; 
  }


void agregar(datos *puntero)//ver que puntero es una COPIA de puntero_inicio
{ //al pasar por valor la función crea una copia del puntero. No modifico el de main
   while (puntero->p_siguiente != 0)
   { //me posiciono en la última instancia utilizando los enlaces
      puntero = puntero->p_siguiente;
   }
   puntero->p_siguiente = new datos; //solicito una nueva instancia 
   //y asigno la dirección en el puntero al prox de la última
   (puntero->p_siguiente)->p_anterior = puntero;// esta línea es importante!!
   cargar(puntero->p_siguiente);
}


Observación : 

En la línea :

(puntero->p_siguiente)->p_anterior = puntero;// esta línea es importante!!

Aprovecho para inicializar el puntero de anterior de la instancia siguiente,  antes de pasar a completar los datos de la instancia siguiente. Esto se puede hacer de otras formas, solo me pareció oportuno hacerlo ya que tengo almacenado el valor de la dirección anterior en ese momento.

La salida del código anterior es: