Lista de Java doblemente vinculada

Una lista vinculada es un tipo de estructura de datos estándar que consta de varios nodos adyacentes. Cada nodo protege la información y la dirección del clúster después de que esté en. Una lista doblemente vinculada es una variación de la lista vinculada. El contenido y el puntero adicional, conocido como el puntero anterior, que están presentes en la lista vinculada única también están presentes en una lista doblemente vinculada. En otras palabras, la lista doblemente vinculada puede brindarle la oportunidad de moverse en ambas direcciones, yo.mi. hacia atrás y hacia adelante, mientras que la lista de unión individual solo se mueve hacia la dirección hacia adelante. En esta guía, vamos a discutir cómo podemos crear una lista de doble enlace en el idioma Java.

Ejemplo 01:

Comenzando con el primer ejemplo de Java de este artículo, veremos cómo se puede crear una lista doblemente vinculada en la programación de Java en unos segundos utilizando algunas líneas de código. El código proporcionado a continuación se puede ejecutar especialmente en el IDE de Eclipse. Este código Java no necesita que se importe ningún paquete de Java antes del inicio de una nueva clase.

Asegúrese de nombrar la clase utilizada en el código de la misma manera que el nombre de su archivo Java I.mi. "prueba". La clase de prueba principal contiene muchas funciones definidas por el usuario junto con su estructura de clase infantil llamada "nodo" que se está utilizando para crear un nodo. La clase de nodo contiene la declaración de datos enteros "D", "P" anteriores y el siguiente nodo consecutivo "n" para que se cree un nodo actual. Esta clase de "nodo" también contiene la función del constructor "nodo" para establecer los datos para un nodo creado actualmente. El nodo de la cabeza "H" y el nodo de cola "T" se han establecido en NULL. A partir de la función Main () de este programa, la lista vinculada "L" se ha creado utilizando la técnica de creación de objetos para la clase principal de "prueba". La llamada de función a la función "Agregar" de la clase "Prueba" se ha realizado utilizando el objeto de lista doblemente vinculado "L" para agregar 5 valores de datos a la lista doblemente vinculada una tras otra.

Asegúrese de agregar los datos enteros a la lista doblemente vinculada. Cuando la función "Agregar" recibe una llamada con el valor de datos "D", ejecutará la función Agregar que comienza con la creación de un nuevo nodo "Newn". Aquí viene la declaración if-else para verificar si el nodo está vacío o no. Si es "nulo", el nodo de cabeza y cola se convertirá en un nodo nuevo, mientras que el nodo anterior y próximo de un nodo principal se establecerá en "NULL" por ahora. El nodo anterior se convertirá en la cabeza y el próximo nodo se convertirá en una cola. De lo contrario, la parte del otro se ejecutará si el cabezal no es "nulo". Aquí, los nodos se cambiarán. El próximo nodo de una cola se convertirá en un nuevo nodo y el nodo anterior de un nuevo nodo "Newn" se convertirá en una cola.

Al mismo tiempo, el nodo de cola se convertirá en un nuevo nodo y la próxima cola se establecerá en NULL. Cuando se ha llamado a la función show (), ejecutará la función "show" debajo del final de la función add (). Aquí, definiremos el nodo actual como el nodo "Cabeza". Si aún así, el nodo principal es nulo, mostrará que la lista vinculada está vacía. De lo contrario, continuará verificando si el nodo actual es nulo o no, junto con la visualización del valor de datos "D" en este nodo actual en particular.

Al final, el texto del nodo actual se convertirá en el nodo actual para la siguiente llamada de función. Aquí nuestra función Main () se completó después de agregar y mostrar los datos de nodos de lista doblemente vinculados. Permítanos copiar, pegar y ejecutar este código Java para ver su salida.

prueba de paquete;
Prueba de clase pública
nodo de clase
int d;
Nodo p;
Nodo n;
nodo público (int d)
este.d = d;

Nodo h, t = nulo;
public void add (int d)
Nodo newn = nuevo nodo (d);
if (h == null)
h = t = Newn;
H.p = nulo;
T.n = nulo;

demás
T.n = Newn;
ramillete.p = t;
t = Newn;
T.n = nulo;

public void show ()
Nodo c = h;
if (h == null)
Sistema.afuera.println ("la lista está vacía");
devolver;

Sistema.afuera.println ("Lista doble vinculada:");
mientras (c != nulo)
Sistema.afuera.Imprimir (C.d + "");
C = C.norte;

public static void main (string [] args)
prueba l = nueva test ();
L.Agregar (11);
L.Agregar (62);
L.Agregar (23);
L.Agregar (14);
L.Agregar (45);
L.Espectáculo();

Después de la ejecución de este código en Eclipse IDE, los 5 valores de datos en la lista doblemente vinculada "L" se han mostrado en el mismo orden. Los agregamos sin cambios en el orden. El punto que debe tenerse en cuenta es que, si no hemos usado la función "Agregar" para agregar datos a una lista doblemente vinculada, podría haber mostrado que la lista doblemente vinculada está actualmente vacía.

Ejemplo 02:

Echemos un vistazo a otro ejemplo de Java. No solo vamos a mostrar una forma de crear un nuevo nodo, sino también una forma de eliminar los nodos de los nodos de inicio y finalización y moverse en ambas direcciones. A partir de la función principal de este código, hemos creado un objeto de lista doblemente vinculado "L" para tipos enteros y declarar una cabeza, cola y tamaño a "0" para la lista vinculada. La función 2 llama a la función "ADDF" que conducirá a una creación temporal de nodo "temp". Si la cabeza no es nula, estableceremos la cabeza anterior como un nodo "temperatura". De lo contrario, la cabeza se convertirá en "temperatura" y si la cola es nula, se convertirá en un nodo "temperatura".

La llamada de función en la función "ADDL" conducirá a agregar un nodo del elemento de datos a la izquierda del nodo actual utilizando la forma similar que hemos adoptado para agregar un nodo en el lado derecho. Las condiciones utilizadas en sus declaraciones "si" se revertirán esta vez. La llamada de función "Movefor" lo lleva a avanzar en una lista doblemente vinculada. Después de avanzar, probamos la llamada de función a las funciones "RMVF" y "RMVL" para eliminar los nodos de datos recién agregados en el primero y el último de la lista doblemente vinculada.

prueba de paquete;
importar java.utilizar.NosuchelementException;
prueba de clase pública
nodo privado h;
nodo privado t;
tamaño privado int;
Public test ()
tamaño = 0;

Nodo de clase privada
T d;
Nodo n;
Nodo p;
nodo público (t d, nodo n, nodo p)
este.d = d;
este.n = n;
este.p = p;

public int size ()
tamaño de retorno;
Public boolean isEtimty ()
tamaño de retorno == 0;
public void addf (t d)
Nodo temp = nuevo nodo (d, h, nulo);
if (h != nulo)
H.p = temp;

h = temp;
if (t == null)
t = temp;

tamaño ++;
Sistema.afuera.println ("Agregar d:"+d);

public void addl (t d)
Nodo temp = nuevo nodo (d, nulo, t);
si t != nulo)
T.n = temp;

t = temp;
if (h == null)
h = temp;

tamaño ++;
Sistema.afuera.println ("Agregar datos:"+D);

public void Movefor ()
Sistema.afuera.println ("iterando hacia adelante.");
Nodo temp = h;
mientras (temperatura != nulo)
Sistema.afuera.println (temperatura.d);
temp = temperatura.norte;

public void Moveback ()
Sistema.afuera.println ("iterando la palabra de espalda.");
Nodo temp = t;
mientras (temperatura != nulo)
Sistema.afuera.println (temperatura.d);
temp = temperatura.pag;

public t rmvf ()
if (size == 0) tirar nueva nosuchelementException ();
Nodo temp = h;
H = H.norte;
H.p = nulo;
tamaño--;
Sistema.afuera.println ("Eliminado D:"+temperatura.d);
Temperadora de retorno.d;

public t rmvl ()
if (size == 0) tirar nueva nosuchelementException ();
Nodo temp = t;
t = t.pag;
T.n = nulo;
tamaño--;
Sistema.afuera.println ("Datos eliminados:"+temperatura.d);
Temperadora de retorno.d;

public static void main (string args [])
intentar
prueba l = nueva test ();
L.Addf (2);
L.Addf (26);
L.ADDL (11);
L.Movefor ();
L.Rmvf ();
L.Rmvl ();
L.Retroceder();
capt (excepción er)
jerga.printStackTrace ();

Después de la ejecución, se han agregado 2 nodos en el inicio y 2 nodos en el punto final mientras avanzan todos los datos del nodo se muestran. Se eliminaron dos nodos y los datos del último nodo se mostraron después de moverse hacia atrás.

Conclusión

El uso de una lista doblemente vinculada es muy común entre los programadores de Java para moverse y trabajar en ambas direcciones. Junto con eso, los ejemplos de Java son la parte importante de este artículo para discutir una forma de crear una lista doblemente vinculada utilizando los nodos de datos, anteriores, actuales y próximos, etc.