Johdanto linkitettyjen luettelojen käyttämiseen Javassa

Tietorakenne käyttää erilaisia ​​ennalta määritettyjä menetelmiä tietojen tallentamiseen, noutamiseen ja poistamiseen, mikä huipentuu tehokkaiden ohjelmien luomiseen. Linkitetty luettelo on suosittu tietorakenne, joka koostuu luettelosta solmuista, jotka on yhdistetty (tai linkitetty).

Mutta miten voit luoda linkitetyn luettelon Javassa? Katsotaanpa.

Jokainen linkitetty luettelo alkaa erityisellä solmulla, jota kutsutaan usein "pääksi" ja jonka vastuulla on osoittaa luettelon alku aina. Pää on tärkeä, koska jokaisen linkitetyn luettelon solmun ei tarvitse seurata fyysisesti seuraajaansa (eli edeltäjän ja seuraajan ei tarvitse olla fyysisesti vierekkäin).

Kuten kaikki tietorakenteet, linkitetty luettelo helpottaa luomista, hakua, lisäämistä ja tuhoamista joukon ennalta määritettyjä toimintoja, joita kuka tahansa kehittäjä voi käyttää.

Java -ohjelmassa, joka on suunniteltu luomaan ja käsittelemään linkitettyjä luetteloita, on kolme erottuvaa osaa; solmuluokka, linkitetty luetteloluokka ja ohjain. Vaikka nämä kolme osaa voidaan yhdistää yhdeksi tiedostoksi, tietotekniikassa on suunnitteluperiaate, joka tunnetaan nimellä "huolenaiheiden erottaminen", joka jokaisen kehittäjän pitäisi tietää.

Huolien erottaminen -periaate edellyttää, että koodin jokainen osa, joka käsittelee tiettyä huolenaihetta, on erotettava toisistaan. Tämä periaate auttaa sinua luomaan puhtaamman (luettavamman) koodin ja on ihanteellinen tietorakenteiden luomiseen.

Ensimmäinen vaihe linkitetyn luettelon luomisessa Javassa on solmuluokan luominen. Solmuluokalla pitäisi olla kaksi määritettä; yksi määritteistä edustaa solmun dataosaa, kun taas toinen attribuutti edustaa linkitettyä osaa. Solmuluokassa pitäisi olla myös konstruktori, getterit ja setterit.

Aiheeseen liittyviä: Opi luomaan luokkia Javalla

Getterit ja setterit sallivat muiden luokkien (kuten linkitetyn luetteloluokan) käyttää linkitetyn luettelon eri solmuja.

Solmuluokan esimerkki

Alla on esimerkki solmuluokasta, jotta saat käsityksen siitä, mitä tarkoitamme:

public class Node {
yksityinen int Tiedot;
yksityinen solmu NextNode;
//constructor
public Node () {
Data = 0;
NextNode = null;
}
// getterit ja setterit
public int getData () {
palauttaa tiedot;
}
public void setData (int data) {
Data = data;
}
public Node getNextNode () {
return NextNode;
}
public void setNextNode (Node nextNode) {
NextNode = seuraavaNode;
}
}

Tässä esimerkissä data -attribuutti tallentaa kokonaislukuarvot. Nyt kun sinulla on solmuluokka, on aika siirtyä linkitettyyn luetteloon.

Alla on esimerkki linkitetystä luettelosta Javassa.

julkinen luokka LinkedList {
yksityinen solmupää;
//constructor
julkinen LinkedList () {
Pää = nolla;
}
}

Yllä oleva koodi luo linkitetyn luetteloluokan, mutta ilman eri toimintoja luokka voidaan nähdä tyhjän kuoren vastineena. Linkitetyssä luettelotietorakenteessa on useita toimintoja, joita voidaan käyttää sen täyttämiseen:

• Lisäosa edessä.
• Aseta keskelle.
• Aseta takaosaan.

Aiheeseen liittyviä: Tietorakenteiden luominen JavaScript ES6 -luokilla

Linkitetty luettelokokoelma lisäysmenetelmiä on yksi syy siihen, miksi kehittäjä saattaa päättää käyttää näitä tietoja rakentaa toisen tietorakenteen, kuten pinojen, päälle (mikä sallii vain lisäämisen ja poistamisen ylhäältä).

Lisäosan käyttö menetelmällä

Etuosan lisäys, kuten nimestä voi päätellä, lisää uusia tietoja (tai uusia solmuja) linkitetyn luettelon eteen.

Esimerkki lisäysmenetelmästä

Alla on esimerkki siitä, miten voit lisätä uusia tietoja luettelosi eteen.

 // lisää solmu eteen -menetelmällä
public void insertAtFront (int -avain) {
// luoda uusi solmu solmuluokan avulla
Solmun lämpötila = uusi solmu ();
// tarkista, onko väliaikaisen solmun luominen onnistunut
// määritä sille käyttäjän toimittamat tiedot
jos (Temp! = null) {
Temp.setData (avain);
Temp.setNextNode (null);
// tarkista, onko linkitetyn luettelon pää tyhjä
// määritä juuri luotu solmu pään asentoon
jos (pää == nolla) {
Pää = Lämpötila;
}
// jos solmu on jo pään asennossa
// lisää uusi solmu siihen ja aseta se pääksi
muu {
Temp.setNextNode (Head);
Pää = Lämpötila;
}
}
}

The insertAtFront yllä olevan esimerkin menetelmän avulla käyttäjä voi lisätä uusia solmuja tiettyyn linkitettyyn luetteloon.

Esimerkki lisäosan käyttämisestä edessä

Alla on esimerkki siitä, kuinka levität etulevyä.

julkisen luokan kuljettaja {
// suorittaa ohjelman
public staattinen void main (String [] args) {
// Luo uusi linkitetty luettelo nimeltä Lista
LinkedList List = uusi LinkedList ();
// lisää jokainen arvo linkitetyn luettelon eteen uutena solmuna
List.insertAtFront (10);
List.insertAtFront (8);
List.insertAtFront (6);
List.insertAtFront (4);
List.insertAtFront (2);
}
}

The Kuljettaja luokka (joka on nimi, joka usein annetaan suoritettavalle luokalle Javassa), luo LinkedList -luokan avulla viiden parillisen numeron linkitetyn luettelon. Yllä olevaa koodia tarkasteltaessa pitäisi olla helppo nähdä, että numero "2" on linkitetyn luettelon pääpisteessä. Mutta miten voit vahvistaa tämän?

Näytä kaikki solmut -menetelmän käyttäminen

Näytä kaikki solmut -menetelmä on olennainen linkitetty luettelomenetelmä. Ilman sitä kehittäjä ei näe linkitetyn luettelon solmuja. Se kulkee linkitetyn luettelon läpi (alkaen päästä) ja tulostaa kussakin luettelon muodostavassa solmussa tallennetut tiedot.

Näytä esimerkki kaikista solmuista

Alla on esimerkki kaikkien huomautusten näyttömenetelmän käyttämisestä Javassa.

// näytä kaikki solmut -menetelmä
public void displayAllNodes () {
// Luo uusi solmupuhelu Temp ja määritä se linkitetyn luettelon päähän
// jos pään arvo on tyhjä, linkitetty luettelo on tyhjä
Solmun lämpötila = pää;
jos (pää == nolla) {
System.out.println ("Lista on tyhjä.");
palata;
}
System.out.println ("Lista:");
while (Temp! = null) {
// tulosta kunkin solmun tiedot konsoliin (alkaen päästä)
System.out.print (Temp.getData () + "");
Lämpötila = Temp.getNextNode ();
} 
}

Nyt kun displayAllNodes menetelmä on lisätty LinkedList luokassa voit tarkastella linkitettyä luetteloa lisäämällä kuljettajaluokkaan yhden koodirivin.

Esimerkki Näytä kaikki solmut -menetelmästä

Alla näet, miten käytät kaikkien solmujen näyttömenetelmää.

// tulostaa solmut linkitetyssä luettelossa
List.displayAllNodes (); 

Yllä olevan koodirivin suorittaminen tuottaa seuraavan tuloksen konsolissa:

Lista:

2 4 6 8 10

Find Node -menetelmän käyttäminen

On tapauksia, joissa käyttäjä haluaa löytää tietyn solmun linkitetystä luettelosta.

Esimerkiksi ei olisi käytännöllistä, että pankit, joilla on miljoonia asiakkaita, tulostaisivat kaikkien asiakkaiden tietokannan, kun heidän tarvitsee vain nähdä tietyn asiakkaan tiedot.

Siksi sen sijaan, että käytät displayAllNodes menetelmä, tehokkaampi tapa on löytää yksittäinen solmu, joka sisältää vaaditut tiedot. Siksi yksittäisen solmumenetelmän etsiminen on tärkeää linkitetyn luettelon tietorakenteessa.

Etsi solmumenetelmän esimerkki

Alla on esimerkki löytää solmu menetelmä.

// etsi yksittäinen solmu avaimella
public boolean findNode (int -avain) {
// Luo uusi solmu ja aseta se linkitetyn luettelon päähän
Solmun lämpötila = pää;
// kun nykyinen solmu ei ole tyhjä
// tarkista, vastaavatko tiedot käyttäjän antamaa avainta
while (Temp! = null) {
if (Temp.getData () == avain) {
System.out.println ("Solmu on luettelossa"); 
palaa tosi;
}
// siirtyä seuraavaan solmuun
Lämpötila = Temp.getNextNode ();
}
// jos avainta ei löytynyt linkitetystä luettelosta
System.out.println ("Solmu ei ole luettelossa"); 
palauta epätosi;
}

Kanssa displayAllNodes menetelmällä, vahvistat, että LinkedList sisältää 5 parillista numeroa 2-10. The findNode yllä oleva esimerkki voi vahvistaa, onko yksi parillisista numeroista numero 4, yksinkertaisesti kutsumalla kuljettajaluokan menetelmä ja antamalla numero parametriksi.

Esimerkki Find Node Method -menetelmän käyttämisestä

Alla on esimerkki siitä, miten voit käyttää Find Node -menetelmää käytännössä.

// tarkista, onko solmu linkitetyssä luettelossa
List.findNode (4);

Yllä oleva koodi tuottaa seuraavan tuloksen konsolissa:

Solmu on luettelossa

Poista solmu -menetelmän käyttäminen

Käyttämällä samaa pankkiesimerkkiä ylhäältä pankin tietokannassa oleva asiakas saattaa haluta sulkea tilinsä. Tässä on hyödyllistä poistaa solmun poistomenetelmä. Se on monimutkaisin linkitetty luettelomenetelmä.

Poista solmu -menetelmä etsii tiettyä solmua, poistaa sen ja linkittää edellisen solmun poistetun solmun jälkeiseen solmuun.

Esimerkki solmumenetelmästä

Alla on esimerkki solmun poistomenetelmästä.

public void findAndDelete (int -avain) { 
Solmun lämpötila = pää; 
Solmu prev = null; 
// tarkista, onko pääsolmulla tiedot 
// ja poista se 
if (Temp! = null && Temp.getData () == avain) { 
Pää = Temp.getNextNode (); 
palata; 
} 
// etsi luettelon muista solmuista 
// ja poista se 
while (Temp! = null) { 
if (Temp.getNextNode (). getData () == avain) { 
prev = Temp.getNextNode (). getNextNode (); 
Temp.setNextNode (edellinen); 
palata; 
} 
Lämpötila = Temp.getNextNode (); 
} 
} 

Esimerkki Poista solmumenetelmä -menetelmästä

Alla on esimerkki solmun poistamismenetelmän käytöstä käytännössä.

// poista solmu, joka pitää tiedot 4
List.findAndDelete (4);
// tulosta kaikki linkitetyn luettelon solmut
List.displayAllNodes ();

Käyttämällä yllä olevia kahta koodiriviä olemassa olevassa Driver-luokassa saat seuraavan tuloksen konsolissa:

Lista:
2 6 8 10

Jos päädyit tämän opetusartikkelin loppuun, olet oppinut:

• Solmuluokan luominen.
• Linkitetyn luetteloluokan luominen.
• Linkitetyn luetteloluokan täyttäminen ennalta määritetyillä menetelmillä.
• Ohjainluokan luominen ja eri linkitettyjen luettelomenetelmien käyttö halutun tuloksen saavuttamiseksi.

Linkitetty luettelo on vain yksi monista tietorakenteista, joiden avulla voit tallentaa, hakea ja poistaa tietoja. Koska sinulla on kaikki mitä tarvitset aloittamiseen, miksi et kokeilisi näitä esimerkkejä itse Javassa?

Miten luodaan ja suoritetaan toimintoja Java -massoilla

Opitko Javaa? Anna matriisien käsitellä tietojasi helposti.

Lue seuraava

Kirjailijasta