Elenco doppiamente collegato

Un elenco collegato è un tipo di struttura di dati standard che consiste in diversi nodi adiacenti. Ogni nodo protegge le informazioni e l'indirizzo del cluster dopo che è in. Un elenco doppiamente collegato è una variazione dell'elenco collegato. Il contenuto e il puntatore aggiuntivo, noto come puntatore precedente, presenti nel singolo elenco collegato sono presenti anche in un elenco doppiamente collegato. In altre parole, l'elenco doppiamente collegato può offrirti l'opportunità di muoverti in entrambe le direzioni, i.e. avanti e indietro, mentre l'elenco singolarmente collegato si sposta solo verso la direzione in avanti. In questa guida, discuteremo di come possiamo creare un elenco a doppio legame in lingua Java.

Esempio 01:

Iniziare con il primo esempio Java di questo articolo, vedremo come un elenco doppiamente collegato può essere creato nella programmazione Java in pochi secondi usando alcune righe di codice. Il codice fornito di seguito può essere eseguito soprattutto nell'IDE ECLIPSE. Questo codice Java non ha bisogno di alcun pacchetto di Java da importare prima dell'inizio di una nuova classe.

Assicurati di nominare la classe utilizzata nel codice uguale al nome del tuo file java i.e. "test". La classe di test principale contiene molte funzioni definite dall'utente insieme alla struttura della classe figlio denominata "nodo" che viene utilizzata per creare un nodo. La classe nodo contiene la dichiarazione di dati interi "D", precedente "P" e il nodo consecutivo "N" successivo per la creazione di un nodo corrente da creare. Questa classe "nodo" contiene anche la funzione costruttore "nodo" per impostare i dati per un nodo attualmente creato. Il nodo della testa "H" e il nodo di coda "T" è stato impostato su NULL. A partire dalla funzione principale () di questo programma, l'elenco collegato "L" è stato creato utilizzando la tecnica di creazione di oggetti per la principale classe "Test". La chiamata della funzione alla funzione "Aggiungi" della classe "Test" è stata eseguita utilizzando l'oggetto elenco doppiamente collegato "L" per aggiungere 5 valori di dati all'elenco doppiamente collegato dopo l'altro.

Assicurati di aggiungere i dati interi all'elenco doppiamente collegato. Quando la funzione "Aggiungi" riceve una chiamata con il valore "D" dei dati, eseguirà la funzione ADD che inizia con la creazione di un nuovo nodo "Newn". Ecco che arriva l'istruzione if-else per verificare se il nodo è vuoto o meno. Se è "null", il nodo della testa e della coda diventerà un nuovo nodo mentre per ora il nodo precedente e successivo di un nodo di testa verrà impostato su "null". Il nodo precedente diventerà testa e il nodo successivo diventerà una coda. Altrimenti, la parte altro verrà eseguita se la testa non è "nulla". Qui, i nodi verranno scambiati. Il nodo successivo di una coda diventerà un nuovo nodo e il nodo precedente di un nuovo nodo "Newn" diventerà una coda.

Allo stesso tempo, il nodo di coda diventerà un nuovo nodo e la coda successiva sarà impostata su NULL. Quando è stata chiamata la funzione show (), eseguirà la funzione "show" sotto la fine della funzione add (). Qui definiremo il nodo corrente come nodo "head". Se ancora, il nodo della testa è nullo, visualizzerà che l'elenco collegato è vuoto. Altrimenti, continuerà a verificare se il nodo corrente è nullo o meno insieme alla visualizzazione del valore dei dati "D" in questo particolare nodo corrente.

Alla fine, il testo del nodo corrente diventerà il nodo corrente per la chiamata di funzione successiva. Qui la nostra funzione principale () è stata completata dopo aver aggiunto e visualizzato i dati dei nodi dell'elenco doppiamente collegato. Copiamoci, incolla ed eseguiamo questo codice Java per vedere il suo output.

Test del pacchetto;
Test della classe pubblica
nodo di classe
int d;
Nodo P;
Nodo n;
nodo pubblico (int d)
Questo.d = d;

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

altro
T.n = newn;
newn.p = t;
t = newn;
T.n = null;

public void show ()
Nodo c = h;
if (h == null)
Sistema.fuori.println ("l'elenco è vuoto");
ritorno;

Sistema.fuori.println ("Elenco doppio collegato:");
mentre (c != null)
Sistema.fuori.Stampa (c.d + "");
c = c.N;

public static void main (string [] args)
test l = new test ();
L.Aggiungi (11);
L.Aggiungi (62);
L.Aggiungi (23);
L.Aggiungi (14);
L.Aggiungi (45);
L.Spettacolo();

Dopo l'esecuzione di questo codice in Eclipse IDE, tutti i 5 valori di dati nell'elenco doppiamente collegato "L" sono stati visualizzati nello stesso ordine. Li abbiamo aggiunti senza modifiche nell'ordine. Il punto da notare è che, se non avessimo utilizzato la funzione "Aggiungi" per aggiungere dati a un elenco doppiamente collegato, potrebbe aver visualizzato che l'elenco doppiamente collegato è attualmente vuoto.

Esempio 02:

Diamo un'occhiata a un altro esempio di Java. Non solo visualizzeremo un modo per creare un nuovo nodo, ma anche un modo per eliminare i nodi dai nodi di inizio e fine e muoverti in entrambe le direzioni. A partire dalla funzione principale di questo codice, abbiamo creato un oggetto elenco doppiamente collegato "L" per i tipi di interi e dichiarare una testa, una coda e una dimensione a "0" per l'elenco collegato. La funzione 2 chiama la funzione "addf" che porterà a una creazione di nodi "temp" temporanea. Se la testa non è nulla, imposteremo la testa precedente come nodo "temp". Altrimenti, la testa diventerà "temp" e se la coda è nulla, diventerà un nodo "temp".

Sulla funzione la chiamata alla funzione "addl" porterà all'aggiunta di un nodo dell'elemento di dati a sinistra del nodo corrente utilizzando il modo simile che abbiamo adottato per aggiungere un nodo sul lato destro. Le condizioni utilizzate nelle sue dichiarazioni "if" saranno invertite questa volta. La chiamata di funzione "MoveFor" ti porta ad andare avanti in un elenco doppiamente collegato. Dopo essere andati avanti, abbiamo provato la chiamata della funzione alle funzioni "RMVF" e "RMVL" per rimuovere i nodi dati appena aggiunti al primo e all'ultimo elenco doppiamente collegato.

Test del pacchetto;
Importa Java.util.NosuchelementException;
Test di classe pubblica
nodo privato H;
nodo privato t;
dimensione privata int;
public test ()
dimensione = 0;

nodo di classe privata
T d;
Nodo n;
Nodo P;
nodo pubblico (t d, nodo n, nodo p)
Questo.d = d;
Questo.n = n;
Questo.p = p;

public int size ()
dimensione di ritorno;
public boolean isempty ()
Restituisci dimensioni == 0;
public void addf (t d)
Nodo temp = nuovo nodo (d, h, null);
Se (h != null)
H.p = temp;

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

dimensione ++;
Sistema.fuori.println ("aggiunta d:"+d);

public void addl (t d)
Nodo temp = nuovo nodo (d, null, t);
Se (t != null)
T.n = temp;

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

dimensione ++;
Sistema.fuori.println ("Aggiunta di dati:"+d);

public void move per ()
Sistema.fuori.println ("iterating forward.");
Nodo temp = h;
mentre (temp != null)
Sistema.fuori.println (temp.D);
temp = temp.N;

public void Movingback ()
Sistema.fuori.println ("iteterating backword.");
Nodo temp = t;
mentre (temp != null)
Sistema.fuori.println (temp.D);
temp = temp.P;

public t rmvf ()
if (size == 0) lancia nuovo NosuchelementException ();
Nodo temp = h;
H = H.N;
H.p = null;
misurare--;
Sistema.fuori.println ("cancellato d:"+temp.D);
restituire temp.D;

public t rmvl ()
if (size == 0) lancia nuovo NosuchelementException ();
Nodo temp = t;
t = t.P;
T.n = null;
misurare--;
Sistema.fuori.println ("dati cancellati:"+temp.D);
restituire temp.D;

public static void main (string args [])
Tentativo
test l = new test ();
L.Addf (2);
L.Addf (26);
L.Addl (11);
L.Move per ();
L.Rmvf ();
L.Rmvl ();
L.Andare indietro();
catch (eccezione er)
er.printStackTrace ();

Dopo l'esecuzione, sono stati aggiunti 2 nodi all'inizio e 2 nodi all'endpoint mentre si muovono in avanti tutti i dati del nodo sono stati visualizzati. Due nodi sono stati eliminati e i dati dell'ultimo nodo sono stati visualizzati dopo essersi spostati all'indietro.

Conclusione

L'uso di un elenco doppiamente collegato è molto comune tra i programmatori Java per muoversi e lavorare in entrambe le direzioni. Insieme a ciò, gli esempi di Java sono la parte importante di questo articolo per discutere di un modo per creare un elenco doppiamente collegato usando i dati, i nodi precedenti, attuali e successivi, ecc.