Java dobbeltkoblet liste

En koblet liste er en type standard datastruktur som består av flere tilstøtende noder. Hver node beskytter informasjonen og adressen til klyngen etter at den er i. En dobbelt koblet liste er en variant av den koblede listen. Innholdet og tilleggspekeren, kjent som Prior Pointer, som er til stede i den enkeltkoblede listen er også til stede i en dobbelt koblet liste. Med andre ord, den dobbeltkoblede listen kan gi deg en mulighet til å bevege deg i begge retninger, i.e. bakover og fremover, mens den enkeltkoblede listen bare beveger seg mot fremoverretning. I denne guiden skal vi diskutere hvordan vi kan lage en dobbeltkoblet liste på Java-språk.

Eksempel 01:

Kom i gang med det første Java -eksemplet på denne artikkelen, vi skal se hvordan en dobbelt koblet liste kan opprettes i Java -programmering i løpet av noen få sekunder ved å bruke noen få kodelinjer. Koden nedenfor kan utføres spesielt i formørkelsen IDE. Denne Java -koden trenger ikke noen pakke med Java som skal importeres før starten av en ny klasse.

Sørg for å navngi klassen som brukes i koden den samme som navnet på Java -filen min i.e. "test". Hovedtestklassen inneholder mange brukerdefinerte funksjoner sammen med sin barneklassestruktur som heter “Node” som brukes til å lage en node. Nodeklassen inneholder erklæringen om et heltalldata “D”, tidligere “P”, og den neste “N” påfølgende node for en gjeldende node som skal opprettes. Denne "node" -klassen inneholder også konstruktørfunksjonen "Node" for å angi dataene for en for øyeblikket opprettet node. Hodeknute “H” og haleknute “T” er satt til NULL. Med utgangspunkt i Main () -funksjonen til dette programmet er den koblede listen “L” opprettet ved hjelp av Object Creation Technique for hoved "Test" -klassen. Funksjonssamtalen til "Legg til" -funksjonen til "Test" -klassen er utført ved hjelp av det dobbeltkoblede listeobjektet "L" for å legge til 5 dataverdier til den dobbeltkoblede listen etter den.

Sørg for å legge heltalldataene til den dobbeltkoblede listen. Når "Add" -funksjonen får en samtale med dataene "D" -verdien, vil den utføre tilleggsfunksjonen som starter med opprettelsen av en ny node "Newn". Her kommer if-ests-setningen for å sjekke om noden er tom eller ikke. Hvis det er "null", vil hodet og haleknuten bli en ny node mens den forrige og neste noden til en hodeknute vil bli satt til "null" for nå. Den forrige noden blir hode og neste node blir en hale. Ellers vil den andre delen bli henrettet hvis hodet ikke er "null". Her vil nodene bli byttet ut. Den neste noden til en hal.

Samtidig vil haleknuten bli en ny node og neste hale vil bli satt til null. Når showet () -funksjonen er kalt, vil den utføre "show" -funksjonen under slutten av add () -funksjonen. Her vil vi definere den gjeldende noden som "hodet" -noden. Hvis det er hodeknuten er null, vil den vise at den koblede listen er tom. Ellers vil den fortsette å sjekke om den gjeldende noden er null eller ikke sammen med å vise datavdien “d” ved denne aktuelle gjeldende noden.

På slutten vil teksten til den gjeldende noden bli den gjeldende noden for neste funksjonssamtale. Her ble vår viktigste () -funksjon fullført etter å ha lagt til og vist de dobbelt koblede listeknuterdataene. La oss bare kopiere, lime inn og kjøre denne Java -koden for å se utdataene.

pakketest;
offentlig klasse test
Klasseknute
int d;
Node P;
Node n;
offentlig node (int d)
dette.d = d;

Node h, t = null;
public void add (int d)
Node newN = ny node (d);
if (h == null)
h = t = newn;
h.p = null;
t.n = null;

annet
t.n = newn;
Newn.p = t;
t = newn;
t.n = null;

public void show ()
Node c = h;
if (h == null)
System.ute.println ("liste er tom");
komme tilbake;

System.ute.Println ("Dobbeltkoblet liste:");
mens (c != null)
System.ute.trykk (c.d + "");
c = c.n;

public static void main (String [] args)
test l = ny test ();
L.Legg til (11);
L.Legg til (62);
L.Legg til (23);
L.Legg til (14);
L.Legg til (45);
L.Forestilling();

Etter at denne koden er utførelsen i Eclipse IDE, har alle de 5 dataverdiene i den dobbeltkoblede listen "L" blitt vist i samme rekkefølge. Vi la dem til uten endring i ordren. Poeng som skal bemerkes er at hvis vi ikke hadde brukt "legge til" -funksjonen for å legge til data i en dobbelt koblet liste, kan det ha vist at den dobbeltkoblede listen for øyeblikket er tom.

Eksempel 02:

La oss se på et annet eksempel på Java. Vi kommer til ikke bare å vise en måte å lage en ny node på, men også en måte å slette nodene fra start- og sluttknuter og bevege seg i begge retninger. Med utgangspunkt i hovedfunksjonen til denne koden, har vi laget et dobbelt koblet listeobjekt “L” for heltallstyper og erklærer et hode, hale og størrelse til “0” for den koblede listen. 2 -funksjonen ringer til "addf" -funksjonen som vil føre til en midlertidig "temp" -nodeoppretting. Hvis hodet ikke er null, vil vi sette det forrige hodet som en "temp" -node. Ellers vil hodet bli "temp", og hvis halen er null, vil det bli en "temp" -node.

På funksjonsanrop til "Addl" -funksjonen vil føre til å legge til en dataelementnode til venstre for den nåværende noden ved å bruke den lignende måten vi har tatt i bruk for å legge til en node på høyre side. Forholdene som brukes i "IF" -uttalelsene vil bli omgjort denne gangen. "MoveFor" -funksjonen samtalen fører til at du går videre i en dobbelt koblet liste. Etter å ha gått videre, prøvde vi funksjonssamtalen til "RMVF" og "RMVL" -funksjonene for å fjerne de nettopp tilførte dataknuter ved den første og siste av den dobbelt koblede listen.

pakketest;
Importer Java.util.NosuchElementException;
Public Class Test
privat node H;
privat node t;
privat int -størrelse;
offentlig test ()
størrelse = 0;

Privat klasseknute
T d;
Node n;
Node P;
offentlig node (T D, Node N, Node P)
dette.d = d;
dette.n = n;
dette.p = p;

public int size ()
returstørrelse;
public boolean isEmpty ()
returstørrelse == 0;
public void addf (t d)
Node temp = ny node (d, h, null);
hvis (h != null)
h.p = temp;

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

størrelse ++;
System.ute.println ("legge til d:"+d);

public void addl (t d)
Node temp = ny node (d, null, t);
hvis (t != null)
t.n = temp;

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

størrelse ++;
System.ute.println ("Legge til data:"+d);

public void moveFor ​​()
System.ute.Println ("iterating fremover.");
Nodet temp = h;
mens (temp != null)
System.ute.Println (temp.d);
temp = temp.n;

public void moveback ()
System.ute.println ("iterating backord.");
Nodet temp = t;
mens (temp != null)
System.ute.Println (temp.d);
temp = temp.p;

public t rmvf ()
if (størrelse == 0) kaste ny nosuchElementException ();
Nodet temp = h;
h = h.n;
h.p = null;
størrelse--;
System.ute.println ("slettet d:"+temp.d);
Retur Temp.d;

public t rmvl ()
if (størrelse == 0) kaste ny nosuchElementException ();
Nodet temp = t;
t = t.p;
t.n = null;
størrelse--;
System.ute.Println ("Slettede data:"+Temp.d);
Retur Temp.d;

public static void main (String args [])
prøv
test l = ny test ();
L.Addf (2);
L.Addf (26);
L.Addl (11);
L.MoveFor ​​();
L.Rmvf ();
L.Rmvl ();
L.Flytte tilbake();
fangst (unntak er)
er.printStackTrace ();

Etter utførelse er 2 noder i starten og 2 noder på endepunktet blitt lagt til mens de beveger seg fremover alle nodens data ble vist. To noder ble slettet og den siste nodedata ble vist etter å ha beveget seg bakover.

Konklusjon

Bruken av en dobbelt koblet liste er veldig vanlig blant Java -programmerere for å flytte og jobbe i begge retninger. Sammen med det er Java -eksemplene den fremste viktige delen av denne artikkelen for å diskutere en måte å lage en dobbelt koblet liste ved hjelp av dataene, tidligere, aktuelle og neste noder osv.