Lista doblemente ligada

Una lista doblemente ligada contiene dos tipos de apuntadores “Siguiente y

Anterior” eso significa que la posición de memoria actual “Invocador” apunta
hacia una posición de memoria diferente “Invocado” de tal manera que
guarda la posición de memoria del “invocado” para poder crear la ruta hacia
esa parte de la memoria (Apuntador Siguiente), pero también el “invocado”
se vuelve invocador al momento de guardar la posición de memoria de su
“Invocador” (Apuntador Anterior).

Insertar datos
Para insertar datos dentro de una lista doble siempre hay tres formas de
ingresar un dato; excepto cuando la cabeza sea nula es decir el primer Nodo
ingresado, si consideramos que vamos a trabajar con números enteros para
poder observar el orden ascendente

 Si el Nodo nuevo es más pequeño que el Nodo cabeza de la lista, se

coloca antes de la cabeza y el nuevo Nodo pasa a ser la nueva Cabeza.
 Cualquier Nodo nuevo que sea mayor al Nodo cabeza de la lista y
Mayor que el Nodo Analizado actualmente y Menor que el Nodo
siguiente al Nodo Analizado actualmente si y solo si no es Nulo. (esto
es para inserción de un Nodo en cualquier parte que no sea ni el
principio ni el final de la lista )
  Si Nodo nuevo es Mayor que el Nodo Analizado actualmente y el
siguiente del Nodo Analizado Actualmente es Nulo, eso significa que va
al final de la lista

public class lista {

Nodo cabeza;

public void insertar(int dato){

Nodo nuevo = new Nodo(dato);

Nodo aux=cabeza;

boolean EstadoInsertado=false;

if(cabeza==null){

cabeza=nuevo;

}else{

do{

if(nuevo.dato<aux.dato){

nuevo.siguiente=aux;

aux.anterior=nuevo;

if(aux.hashCode()==cabeza.hashCode()){

cabeza=nuevo;

EstadoInsertado=true;

}else{

if(aux.siguiente!=null){

if(aux.siguiente.dato<nuevo.dato){
 aux.siguiente=nuevo;

nuevo.anterior=aux;

nuevo.siguiente=aux.siguiente;

aux.siguiente.anterior=nuevo;

EstadoInsertado=true;

}else{

aux.siguiente=nuevo;

nuevo.anterior=aux;

EstadoInsertado=true;

aux=aux.siguiente;

}while(EstadoInsertado==false && aux!=null);

}
Eliminar datos
Para eliminar datos de lista doble de nodos se tiene eliminar los apuntadores
a hacia dicho espacio de memoria y re-apuntar al siguiente Nodo para no
perder la continuidad de la lista.

Hay que tener mucho cuidado en esta parte, porque si se elimina un nodo, se
tiene que eliminar apuntadores, pero luego no los re-apuntamos esto nos va
provocar perdida de información:

 perdemos la continuidad de la lista dado que no sabemos que pasa

después de ese punto.

1 2 3 4

por ejemplo se quiere eliminar el numero 2

utilizamos el siguiente seudocódigo

SI(NodoSelecciondo->siguiente ¡= Null){

NodoSeleccionado->siguiente->anterior=NodoSeleccionado->anterior

SI(NodoSelecciondo->anterior ¡= Null){

NodoSeleccionado->anterior->siguiente=NodoSeleccionado->siguinete

}
2

1 3 4

Buscar Nodo
Para buscar un Nodo solamente se tiene que localizar la cabeza de la lista y
luego ir de siguiente en siguiente con la ayuda de un Nodo aux para poder
recorrer la lista sin afectar los Nodo primordiales como la cabeza de la lista,
hasta encontrar la igualdad de información comparando los datos.

Buscar(){

Nodo Aux;

Boolean estadoBusqueda;

Aux=Cabeza; estadoBusqueda=false;

DO{

If(DatoIngresado==Aux.datoConsultado){

//procesar la información

estadoBusqueda=true; // se termina el ciclo al encontrar la igualdad.

}WHILE(estadoBusqueda==false && Aux!=null);