Listas doblemente enlazadas C++ UP

Estudiantes:
Miguel Gómez
Osvaldo Herrera
Bryan Ruiz
Sander Peguero
Docente:
Jenny Ríos
Tema:
Listas doblemente Enlazadas

LISTAS DOBLEMENTE ENLAZADAS
Las listas doblemente enlazadas son estructuras de datos semejantes a las Listas Enlazadas
Simples.
La asignación de memoria es hecha al momento de la ejecución.
Una lista doblemente enlazada es una lista lineal en la que cada nodo tiene dos enlaces, uno
al nodo siguiente, y otro al anterior.
El nodo típico es el mismo que para construir las listas que hemos visto, salvo que tienen otro
puntero al nodo anterior:
struct nodo
{
int dato;
struct nodo *siguiente;
struct nodo *anterior;
};
DEFINICION:

OPERACIONES SOBRE LA LISTA DOBLEMENTE ENLAZADA:
A. Declaracion de tipo, para manejar listas doblemente enlazadas
B. Inserción de un elemento en la lista
1. Inserción en una lista vacía
2. Inserción al inicio de la lista
3. Inserción al final de la lista
4. Inserción antes de un elemento de la lista
5. Inserción después de un elemento de la lista
C. Eliminación de un elemento de la lista
1. Eliminación en la posición 1 en una lista con un solo elemento
2. Eliminación en la posición 1 en una lista con varios elementos
3. Eliminación en la ultima posición (el ultimo elemento)
4. Eliminación en otra parte de la lista en cierta posición
D. Visualización de la lista
E. Destrucción de la lista

INSERCION DE UN ELEMENTO EN LA LISTA:
INSERCION EN UNA LISTA VACIA
Modelo de la función:
int ins_en_lista_vacia (dl_Lista *lista, char *dato);
Partiremos de que ya tenemos el nodo a insertar y, por supuesto un puntero que apunte a él,
además el puntero que define la lista, que valdrá NULL:
El proceso es muy simple, bastará con que:
1. lista apunta a nodo.
2. lista->siguiente y lista->anterior apunten a null.

INSERCION DE UN ELEMENTO EN LA LISTA:
INSERCION AL INICIO DE LA LISTA
Partimos de una lista no vacía. Para simplificar, consideraremos que lista apunta al
primer elemento de la lista doblemente enlazada:
Insertar en primera posición
El proceso es el siguiente:
1. nodo->siguiente debe apuntar a Lista.
2. nodo->anterior apuntará a Lista->anterior.
3. Lista->anterior debe apuntar a nodo.
Nodo insertado en primera posición
Recuerda que Lista no tiene por qué apuntar a ningún miembro concreto de una
lista doblemente enlazada, cualquier miembro es igualmente válido como
referencia.

#include<iostream>
#define Ascendente 1
#define Descendente 0
using namespace std;
//************************** NODO *********************************//
typedef struct Nodo
{
int dato;
struct Nodo *sgt;
struct Nodo *ant;
}TNodo;
//*****************************************************************//

//************************ LISTA **********************************//
typedef struct LE
{
TNodo *inicio;
}TLE;
//*****************************************************************//
//************************* CREA NODO *****************************//
TNodo *crearNodo(int x)
{
TNodo *nodo = (TNodo*)malloc(sizeof(TNodo));
nodo->dato = x;
nodo->sgt = NULL;
nodo->ant = NULL;

return nodo;
}
//*****************************************************************//
//************************ CREA LISTA *****************************//
TLE *crearLista()
{
TLE *lista = (TLE*)malloc(sizeof(TLE));
lista->inicio = NULL;
return lista;
}
//*****************************************************************//

//************************ INSERTAR *******************************//
void Insertar(TLE *lista, int x)
{
TNodo *nodo = crearNodo(x);
TNodo *p=NULL;
if(lista->inicio == NULL)
{
lista->inicio=nodo;
nodo->ant==NULL;
}
else
{
p = lista->inicio;
while(p->sgt != NULL)

p = p->sgt;
p->sgt = nodo;
nodo->ant=p;
}
}
//*****************************************************************//
//*********************** ELIMINAR ********************************//
void Eliminar(TLE *lista, int dato)
{
TNodo *p = lista->inicio;
TNodo *ant = NULL;

{
if(p->dato==dato)
encontrado=1;
else
{
ant = p;
p = p->sgt;
}
}
if(p!=NULL)
{
if (ant==NULL)

lista->inicio=(lista->inicio)->sgt;
else
{
ant->sgt=p->sgt;
p->sgt->ant=ant;
}
free(p);
}
}
//*****************************************************************//
//************************ BORRAR *********************************//
void Borrar(TLE *lista)
{
TNodo *p = NULL;
while(lista->inicio != NULL)

{
p = lista->inicio;
lista->inicio = p->sgt;
p->sgt->ant==NULL;
free(p);
}
}
//*****************************************************************//
//********************** REPORTAR ********************************//
void Reportar(TLE *lista , int Orden )
{

TNodo *p = lista->inicio;
if( Orden == Ascendente)
{
cout<<" lista -> ";
while(p!=NULL)
{
cout<<p->dato<<" <-> ";
p = p->sgt;
}
cout<<"NULL";

}
else
{
cout<<" NULL ";
while(p->sgt!=NULL)
p = p->sgt;
while(p!=NULL)
{
cout<<" <-> "<<p->dato;
p = p->ant;
}
cout<<" <- Lista";

}
cout<<endl<<endl;
system("pause");
cout<<endl;
}
//*****************************************************************//
//*********************** ESTA VACIA ******************************//
void Vacia(TLE *lista)
{
if(lista->inicio == NULL)
cout<<endl<<" - La Lista Esta Vacia !!! "<<endl;
else

cout<<endl<<" - La Lista No Esta Vacia !!! ";
cout<<endl<<endl;
system("pause");
cout<<endl;
}
//*****************************************************************//
//*****************************************************************//
//*****************************************************************//
int main()
{
system("color f3");
TLE *L=crearLista();

int N,E,i=0;
int opcion;
cout<<endl<<"t----------------------------------------------------------------- ";
cout<<endl<<"t| LISTAS ENLAZADAS DOBLES |";
cout<<endl<<"t| - [ UNIVERSIDAD NACIONAL DE PANAMA ] - |";
cout<<endl<<"t----------------------------------------------------------------- "<<endl;
cout<<endl<<endl;
cout<<" MENU LISTAS DOBLES"<<endl;
cout<<" ------------------ ";
while(1)
{
cout<<endl<<endl;
cout<<" -------------------------------- "<<endl;
cout<<" | 1. Insertar |"<<endl;
cout<<" | 2. Eliminar Elemento |"<<endl;
cout<<" | 3. Borrar Lista |"<<endl;
cout<<" | 4. Mostrar Lista Ascendente |"<<endl;
cout<<" | 5. Mostrar Lista Descendente |"<<endl;
cout<<" | 6. Lista Esta Vacia |"<<endl;
cout<<" | 7. Salir |"<<endl;
cout<<" --------------------------------"<<endl;

do
{
cout<<endl<<endl<<" -> Ingrese Opcion"<<endl;
cout<<" ---------------> ";
cin>>opcion;
}
while(opcion < 1 || opcion > 7);
switch(opcion)
{
case 1:
i++;
cout<<endl<<" - Ingrese ["<<i<<"] elemento: ";
cin>>N;
Insertar(L,N);
break;

case 2:
cout<<endl<<" - Ingrese Elemento a Eliminar: ";
cin>>E;
Eliminar(L,E);
break;
case 3:
Borrar(L);
cout<<endl<<endl;
cout<<" - Se Elimino La Lista Correctamente... ";
cout<<endl<<endl;
system("pause");
cout<<endl;
break;

case 4:
cout<<endl;
Reportar(L,Ascendente);
cout<<endl;
break;
case 5:
cout<<endl;
Reportar(L,Descendente);
cout<<endl;
break;

case 6:
Vacia(L);
break;
case 7:
exit(1);
default:
cout<<endl<<endl;
cout<<" La Opcion No es Valida !!!!!!!!!:";
}
}
cout<<endl<<endl;
system("PAUSE");
return EXIT_SUCCESS;
}
//*****************************************************************//

Listas doblemente enlazadas C++ UP

Más contenido relacionado

La actualidad más candente (20)

Similar a Listas doblemente enlazadas C++ UP (20)

Último (20)

Listas doblemente enlazadas C++ UP