LISTAS DOBLES ENLAZADAS

Este tipo de listas son muy semejantes a las listas enlazadas simples con la
diferencia, de que cada nodo posee dos enlaces, el primer puntero apunta al
nodo anterior o null si es el primero y otro al nodo siguiente, o null si es el
ultimo nodo.

Creacin de la clase Nodo

Comenzaremos creando la clase Nodo con sus dos enlaces.
?
1 public class Nodo {
2 public int info;
3 public Nodo sgte;
4 public Nodo ante;
5 public Nodo(){
6
7 }
8 public Nodo (int x){
9 this.info = x;
10 this.sgte = null;
11 this.ante = null;
12 }
13 }
Como podemos apreciar la clase nodo tiene dos punteros los cuales estn
inicializados con null sgte que apunta al ultimo nodo, y ante que apunta a
primer nodo.

Operaciones con listas enlazadas:

Se pueden realizar muchas operaciones con estas listas, segn sea el caso que
se lo requiera aqui les presentamos las mas importantes:

Insertar un elemento al inicio de la lista.

 Insertar un elemento al final de la lista.

Insertar despus.

Visualizar los elementos de la lista.

Buscar.

Eliminar.

Insertar Inicio: Declaramos el nodo cab(cabezera) y Nodo ptr(puntero),

luego los inicializamos a null.

private Nodo cab;

private Nodo ptr;
public ListaDoblementeEnlazada()
{
cab=ptr=null;
}
}
Declaramos un mtodo para conocer si la lista esta vaca;
?
1 boolean estaVacia() {
2 boolean vacia = false;
3 if (cab == null)
4 {
5 vacia = true;
6 }
7 return vacia;
8 }
Mtodo para insertar al inicio.
?
1 public ListaDoblementeEnlazada InsertarInicio(int x)
2 {
3 Nodo nuevo = new Nodo(x);
4 if (estaVacia()) {
5 cab = ptr = nuevo;
6 } else {
7 nuevo.sgte =cab;
8 cab.ante = nuevo;
9 cab = nuevo;
10 }
11 return this;
12 }

Insertar fin:
?
1 public ListaDoblementeEnlazada InsertarFin(int x)
2 {
3 Nodo nuevo = new Nodo(x);
4 if (estaVacia()) {
5 cab = ptr = nuevo;
6 } else {
7 ptr.sgte = nuevo;
8 nuevo.ante = ptr;
9 ptr = nuevo;
10 }
11 return this;
12 }
Insertar Despus:
?
1
public ListaDoblementeEnlazada InsertarDespues(Nodo
2
anterior ,int x)
3
{
4
Nodo nuevo = new Nodo(x);
5
nuevo.sgte = anterior.sgte;
6 if (anterior.sgte != null)
7 {
8 anterior.sgte.ante = nuevo;
9 }
1 anterior.sgte = nuevo;
0 nuevo.ante = anterior;
11 return this;
1 }
2
Imprimir la lista: Se declara un nodo n al cual se le asigna la cabecera de la
lista, con la estructura de control while se va imprimiendo todos los nodos
asta que la cabecera sea nula.
?
1 public void Visualizar()
2 {
3 Nodo n;
4 n = cab;
5 while (n != null)
6 {
7 System.out.print("<- n.info="">");
8 n = n.sgte;
9 }
10 }
11 <!----->
Eliminar Nodo:
?
1 public void Eliminar(int entrada)
2 {
3 Nodo actual;
4 boolean encontrado = false;
5 actual = cab;
6 while ((actual != null) && (!encontrado))
7 {
8 encontrado = (actual.info == entrada);
9 if (!encontrado)
1 {
0 actual = actual.sgte;
11 }
1 }
2 if (actual != null){//distingue entre nodo
1 cabecera o resto de la lista
3 if (actual == cab)
1 {
4 cab = actual.sgte;
1 if (actual.sgte != null)
5 {
1 actual.sgte.ante = null;
6 }
}
1
else if (actual.sgte != null) // No es
7
el ltimo nodo
1
{
8
actual.ante.sgte = actual.sgte;
1
9
2
0
2
1
2
2
2
3
2
4
2
5
2 actual.sgte.ante = actual.ante;
6 }
2 else // ltimo nodo
7 {
2 actual.ante.sgte = null;
8 }
2 if (actual == ptr)
9 {
3 ptr = actual.ante;
0 }
3 actual = null;
1 }
3 }
2
3
3
3
4
3
5
3
6
3
7
3
8
Buscar Nodo: Se recorre la lista comparando si el valor ingresado(dato), es
igual a alguno valore de la lista, en caso de encontrarlo lo retorna.
?
1
public Nodo Buscar(int dato)
2
{
3
Nodo indice;
4
for (indice = cab; indice != null; indice =
5
indice.sgte)
6 {
7 if (dato == indice.info)
8 {
9 return indice;
1 }
0 }
11 return null;
1 }
2
Ejercicio:
Realizar un programa que permita crear una lista doblemente enlazada
para un tipo de dato entero, que guarde en un archivo y a continuacin
realice las siguientes actividades.

1. Insertar un elemento entero al inicio de la lista.

2. Insertar un elemento al final de la lista.

3. Insertar despus.

4. Visualizar los elementos de la lista.

5. Buscar.

6. Eliminar.

7. Obtener el mayor valor.

8. Ordenar la lista doblemente enlazada.

9. Contabilizar los elementos de la lista.

10.Cantidad de nmeros perfectos.

11.Cantidad de nmeros primos.

12.Guardar en un archivo.