Johdanto linkitettyjen luettelojen käyttämiseen Javassa

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.



Miten linkitetty luettelo toimii?

Jokainen linkitetty luettelo alkaa erityisellä solmulla, jota kutsutaan usein nimellä 'head', jonka vastuulla on osoittaa luettelon alku aina. Pää on tärkeä, koska jokaisen linkitetyn luettelon solmun ei tarvitse seurata seuraajaansa fyysisesti (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ää.

Linkitetyn luettelon luominen Javassa

Java -ohjelmassa, joka on suunniteltu luomaan ja käsittelemään linkitettyjä luetteloita, on kolme erillistä 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 Javassa

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 {
private int Data;
private Node NextNode;
//constructor
public Node() {
Data = 0;
NextNode = null;
}
//getters and setters
public int getData() {
return Data;
}
public void setData(int data) {
Data = data;
}
public Node getNextNode() {
return NextNode;
}
public void setNextNode(Node nextNode) {
NextNode = nextNode;
}
}

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

Esimerkki linkitetystä luettelosta

Alla on esimerkki linkitetystä luettelosta Javassa.

public class LinkedList {
private Node Head;
//constructor
public LinkedList() {
Head = null;
}
}

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äysmenetelmistä on yksi syy siihen, miksi kehittäjä saattaa käyttää tätä tietorakennetta toisen tietorakenteen, kuten pinojen, sijaan (mikä sallii vain lisäyksen 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.

//insert node at front method
public void insertAtFront(int key) {
//create a new node using the node class
Node Temp = new Node();
//check if the Temp node was successfully created
//assign the data that was provides by the user to it
if(Temp != null) {
Temp.setData(key);
Temp.setNextNode(null);

//check if the head of the linked list is empty
//assign the node that was just created to the head position
if(Head == null) {
Head = Temp;
}
//if a node is already at the head position
//add the new node to it and set it as the head
else {
Temp.setNextNode(Head);
Head = Temp;
}
}
}

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ä.

public class Driver {
//executes the program
public static void main(String[] args) {
//create a new linked list called List
LinkedList List = new LinkedList();
//add each value to the front of the linked list as a new node
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?

kuinka katsella netflixiä verkossa ystävien kanssa

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 (päästä alkaen) 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.

//display all nodes method
public void displayAllNodes() {
//create a new node call Temp and assign it to the head of the linked list
//if the head has a null value then the linked list is empty
Node Temp = Head;
if (Head == null){
System.out.println('The list is empty.');
return;
}
System.out.println('The List:');

while(Temp != null) {
//print the data in each node to the console(starting from the head)
System.out.print(Temp.getData() + ' ');
Temp = Temp.getNextNode();
}
}

Nyt kun displayAllNodes menetelmä on lisätty LinkedList luokassa voit tarkastella linkitettyä luetteloa lisäämällä yksittäisen koodirivin ohjainluokkaan.

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

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

//print the nodes in a linked list
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ä.

//search for a single node using a key
public boolean findNode(int key) {
//create a new node and place it at the head of the linked list
Node Temp = Head;
//while the current node is not empty
//check if its data matches the key provided by the user
while (Temp != null) {
if (Temp.getData() == key) {
System.out.println('The node is in the list');
return true;
}
//move to the next node
Temp = Temp.getNextNode();
}
//if the key was not found in the linked list
System.out.println('The node is not in the list');
return false;
}

Kanssa displayAllNodes menetelmällä, vahvistat, että LinkedList sisältää 5 parillista numeroa 2-10 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ä.

//check if a node is in the linked list
List.findNode(4);

Yllä oleva koodi tuottaa seuraavan tuloksen konsolissa:

The node is in the list

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 key) {
Node Temp = Head;
Node prev = null;
//check if the head node holds the data
//and delete it
if (Temp != null && Temp.getData() == key) {
Head = Temp.getNextNode();
return;
}
//search the other nodes in the list
//and delete it
while (Temp != null) {
if (Temp.getNextNode().getData() == key ) {
prev = Temp.getNextNode().getNextNode();
Temp.setNextNode(prev);
return;
}
Temp = Temp.getNextNode();
}
}

Esimerkki Poista solmumenetelmä -menetelmästä

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

merkkejä siitä, että kiintolevysi ei toimi
//delete the node that holds the data 4
List.findAndDelete(4);
//print all nodes in the linked list
List.displayAllNodes();

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

The List:
2 6 8 10

Nyt voit luoda linkitettyjä luetteloita Javassa

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?

Jaa Jaa Tweet Sähköposti Miten luodaan ja suoritetaan toimintoja Java -massoilla

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

Lue seuraava Liittyvät aiheet
  • Ohjelmointi
  • Java
  • Ohjelmointi
  • Koodausvinkkejä
Kirjailijasta Kadeisha Kean(21 artikkelia julkaistu)

Kadeisha Kean on täyspinoinen ohjelmistokehittäjä ja tekninen/teknologinen kirjoittaja. Hänellä on selkeä kyky yksinkertaistaa joitain monimutkaisimpia teknologisia käsitteitä; tuottaa materiaalia, jonka jokainen tekniikan aloittelija voi helposti ymmärtää. Hän on intohimoinen kirjoittamiseen, mielenkiintoisten ohjelmistojen kehittämiseen ja maailman matkustamiseen (dokumenttielokuvien kautta).

Lisää Kadeisha Keanilta

tilaa uutiskirjeemme

Liity uutiskirjeeseemme saadaksesi teknisiä vinkkejä, arvosteluja, ilmaisia ​​e -kirjoja ja ainutlaatuisia tarjouksia!

Klikkaa tästä tilataksesi