Liste Java doublement liée

Une liste liée est un type de structure de données standard qui se compose de plusieurs nœuds adjacents. Chaque nœud protège les informations et l'adresse du cluster une fois qu'elle est en. Une liste doublement liée est une variation de la liste liée. Le contenu et le pointeur supplémentaire, connu sous le nom de pointeur précédent, qui sont présents dans la liste liée unique sont également présents dans une liste doublement liée. En d'autres termes, la liste doublement liée peut vous offrir une opportunité de vous déplacer dans les deux sens, je.e. en arrière et en avant, tandis que la liste liée individuellement se déplace vers la direction avant. Dans ce guide, nous allons discuter de la façon dont nous pouvons créer une liste à double liaison en langue java.

Exemple 01:

En commençant par le premier exemple Java de cet article, nous allons voir comment une liste doublement liée peut être créée dans la programmation Java en quelques secondes en utilisant quelques lignes de code. Le code fourni ci-dessous peut être exécuté surtout dans l'IDE Eclipse. Ce code Java n'a pas besoin d'importer un package de Java avant le début d'une nouvelle classe.

Assurez-vous de nommer la classe utilisée dans le code comme le nom de votre fichier java i.e. "test". La classe de test principale contient de nombreuses fonctions définies par l'utilisateur ainsi que sa structure de classe enfant nommée «nœud» qui est utilisée pour créer un nœud. La classe de nœud contient la déclaration d'une donnée entière «D», «P» précédent et le nœud consécutif suivant «N» pour un nœud actuel à créer. Cette classe «nœud» contient également la fonction du constructeur «nœud» pour définir les données d'un nœud actuellement créé. Le nœud de tête «H» et le nœud de queue «T» a été défini sur NULL. À partir de la fonction principale () de ce programme, la liste liée «L» a été créée en utilisant la technique de création d'objets pour la classe principale «Test». L'appel de fonction à la fonction «Ajouter» de la classe «Test» a été effectué à l'aide de l'objet de liste doublement lié «L» pour ajouter 5 valeurs de données à la liste doublement liée l'une après l'autre.

Assurez-vous d'ajouter les données entières à la liste doublement liée. Lorsque la fonction «Ajouter» obtient un appel avec la valeur des données «D», il exécutera la fonction ADD qui commence par la création d'un nouveau nœud «newn». Voici la déclaration IF-Else pour vérifier si le nœud est vide ou non. S'il s'agit de «null», le nœud de tête et de queue deviendra un nouveau nœud tandis que le nœud précédent et suivant d'un nœud de tête sera défini sur «null» pour l'instant. Le nœud précédent deviendra la tête et le prochain nœud deviendra une queue. Sinon, la partie ELSE sera exécutée si la tête n'est pas «nul». Ici, les nœuds seront échangés. Le prochain nœud d'une queue deviendra un nouveau nœud et le nœud précédent d'un nouveau nœud «newn» deviendra une queue.

Dans le même temps, le nœud de queue deviendra un nouveau nœud et la prochaine queue sera définie sur NULL. Lorsque la fonction Show () a été appelée, elle exécutera la fonction «Show» sous la fin de la fonction Add (). Ici, nous définirons le nœud actuel comme le nœud «tête». Si encore, le nœud de tête est nul, il affichera que la liste liée est vide. Sinon, il continuera de vérifier si le nœud actuel est nul ou non avec l'affichage de la valeur des données «D» à ce nœud actuel particulier.

À sa fin, le texte du nœud actuel deviendra le nœud actuel de l'appel de fonction suivante. Ici, notre fonction principale () a été terminée après l'ajout et l'affichage des données de nœuds de liste doublement liés. Laissez-nous simplement copier, coller et exécuter ce code Java pour voir sa sortie.

test de package;
Test de classe publique
classe node
int d;
Node P;
Nœud n;
Node public (int d)
ce.d = d;

Nœud h, t = null;
public void add (int d)
Nœud newn = nouveau nœud (d);
if (h == null)
h = t = newn;
H.p = null;
t.n = null;

autre
t.n = newn;
nouveau.p = t;
t = newn;
t.n = null;

public void show ()
Nœud c = h;
if (h == null)
Système.dehors.println ("List est vide");
retour;

Système.dehors.println ("Liste à double lien:");
tandis que (c != null)
Système.dehors.imprimer (c.d + "");
C = C.N;

public static void main (String [] args)
test l = nouveau test ();
L.Ajouter (11);
L.Ajouter (62);
L.Ajouter (23);
L.Ajouter (14);
L.Ajouter (45);
L.Montrer();

Après l'exécution de ce code dans Eclipse IDE, les 5 valeurs de données dans la liste doublement liée «L» ont été affichées dans le même ordre. Nous les avons ajoutés sans changement dans l'ordre. Le point à noter est que, si nous n'avions pas utilisé la fonction «Ajouter» pour ajouter des données à une liste doublement liée, il aurait pu afficher que la liste doublement liée est actuellement vide.

Exemple 02:

Jetons un coup d'œil à un autre exemple de java. Nous allons non seulement afficher un moyen de créer un nouveau nœud, mais aussi un moyen de supprimer les nœuds des nœuds de début et de fin et de se déplacer dans les deux sens. À partir de la fonction principale de ce code, nous avons créé un objet de liste doublement lié «L» pour les types entiers et déclarer une tête, une queue et une taille à «0» pour la liste liée. La fonction 2 appelle à la fonction «addf» qui conduira à une création de nœud «temporaire» temporaire. Si la tête n'est pas nul, nous définirons la tête précédente comme un nœud «temporaire». Sinon, la tête deviendra «température» et si la queue est nulle, elle deviendra un nœud «temporaire».

Sur l'appel de fonction à la fonction «addl» conduira à l'ajout d'un nœud d'élément de données à gauche du nœud actuel en utilisant la même manière que nous avons adoptée pour ajouter un nœud sur le côté droit. Les conditions utilisées dans ses déclarations «IF» seront inversées cette fois. L'appel de fonction «Movefor» vous amène à avancer dans une liste doublement liée. Après avoir progressé, nous avons essayé l'appel de fonction aux fonctions «RMVF» et «RMVL» pour supprimer les nœuds de données juste ajoutés au premier et dernier de la liste doublement liée.

test de package;
Importer Java.user.NosuchementElementException;
test de classe publique
Node privé H;
nœud privé t;
Taille INT privée;
test public ()
taille = 0;

nœud de classe privée
T D;
Nœud n;
Node P;
Node public (T D, Node n, nœud p)
ce.d = d;
ce.n = n;
ce.p = p;

public int size ()
taille de retour;
public booléen iSempty ()
taille de retour == 0;
public void addf (t d)
Node temp = nouveau nœud (d, h, null);
si (h != null)
H.p = temp;

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

taille ++;
Système.dehors.println ("Adding d:" + d);

public void addl (t d)
Node temp = nouveau nœud (d, null, t);
si (t != null)
t.n = temp;

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

taille ++;
Système.dehors.println ("Ajout de données:" + d);

public void movefor ()
Système.dehors.println ("iterating vers l'avant.");
Node temp = h;
tandis que (temp != null)
Système.dehors.println (temp.d);
temp = temp.N;

public void moveback ()
Système.dehors.println ("mot arrière itérant.");
Node temp = t;
tandis que (temp != null)
Système.dehors.println (temp.d);
temp = temp.P;

public t rmvf ()
if (size == 0) lancer un nouveau nosuchementElementException ();
Node temp = h;
H = H.N;
H.p = null;
taille--;
Système.dehors.println ("supprimé d:" + temp.d);
retour à la température.d;

public t rmvl ()
if (size == 0) lancer un nouveau nosuchementElementException ();
Node temp = t;
t = t.P;
t.n = null;
taille--;
Système.dehors.println ("Données supprimées:" + temp.d);
retour à la température.d;

public static void main (String args [])
essayer
test l = nouveau test ();
L.Addf (2);
L.Addf (26);
L.Addl (11);
L.MovelFor ();
L.Rmvf ();
L.Rmvl ();
L.Moveback ();
catch (exception er)
er.printStackTrace ();

Après l'exécution, 2 nœuds au début et 2 nœuds au point de terminaison ont été ajoutés tout en avançant toutes les données du nœud affichées. Deux nœuds ont été supprimés et les données du dernier nœud ont été affichées après avoir reculé.

Conclusion

L'utilisation d'une liste doublement liée est très courante parmi les programmeurs Java pour se déplacer et travailler dans les deux sens. Parallèlement à cela, les exemples Java sont la partie la plus importante de cet article pour discuter d'un moyen de créer une liste doublement liée en utilisant les données, les nœuds précédents, actuels et suivants, etc.