Bevezetés a hivatkozott listák használatába a Java -ban

Bevezetés a hivatkozott listák használatába a Java -ban

Az adatstruktúra különböző előre meghatározott módszereket használ az adatok tárolására, visszakeresésére és törlésére, ami a hatékony programok létrehozásában végződik. A linkelt lista egy népszerű adatstruktúra, amely összekapcsolt (vagy összekapcsolt) csomópontok listájából áll.





De hogyan hozhat létre linkelt listát a Java -ban? Lássuk.



Hogyan működik a linkelt lista?

Minden linkelt lista egy speciális csomóponttal kezdődik, amelyet gyakran „fejnek” neveznek, és amelynek feladata, hogy mindenkor a lista elejére mutasson. A fej azért fontos, mert a hivatkozott lista minden csomópontjának nem kell fizikailag követnie az utódját (vagyis az elődnek és az utódnak nem kell fizikailag szomszédosnak lenniük).





Mint minden adatszerkezet, a linkelt lista is megkönnyíti a létrehozást, visszakeresést, beillesztést és megsemmisítést az előre meghatározott függvények segítségével, amelyeket bármely fejlesztő használhat.

Linkelt lista létrehozása Java nyelven

A hivatkozott listák létrehozására és kezelésére szolgáló Java programnak három megkülönböztető szakasza lesz; a csomópont osztály, a linkelt lista osztály és az illesztőprogram. Bár ez a három szakasz egy fájlban egyesülhet, a számítástechnikában létezik egy tervezési elv, az úgynevezett „aggodalmak szétválasztása”, amelyet minden fejlesztőnek tudnia kell.



Az aggályok szétválasztása elve azt írja elő, hogy a kód minden olyan részét el kell különíteni, amely egy adott problémát kezel. Ez az elv segít tisztább (olvashatóbb) kód létrehozásában, és ideális adatstruktúrák létrehozásához.

Az összekapcsolt lista létrehozásának első lépése a Java -ban egy csomópont -osztály létrehozása. Egy csomópont osztálynak két attribútummal kell rendelkeznie; az egyik attribútum a csomópont adatrészét, míg a másik attribútum a kapcsolt részt képviseli. A csomópontosztálynak rendelkeznie kell konstruktorral, getterekkel és setterekkel is.



Összefüggő: Ismerje meg, hogyan hozhat létre osztályokat Java -ban

A getters és setters lehetővé teszi, hogy más osztályok (például a linkelt lista osztály) hozzáférjenek a linkelt listán belüli különböző csomópontokhoz.



Példa csomópont osztályra

Az alábbiakban bemutatunk egy csomópont osztály példát, hogy megértsük, mire gondolunk:


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;
}
}

Ebben a példában az adatattribútum egész számokat tárol. Most, hogy megvan a csomópont -osztály, ideje továbblépni a linkelt listára.

Példa linkelt listára

Az alábbiakban egy példa a Java -ban található linkelt listára.

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

A fenti kód létrehoz egy összekapcsolt listaosztályt, azonban különféle műveletek nélkül az osztály egy üres héj megfelelőjének tekinthető. Az összekapcsolt lista adatstruktúrája számos műveletet tartalmaz a kitöltéséhez:

  • Betét az elején.
  • Helyezze be a közepébe.
  • Helyezze be a hátsó részbe.

Összefüggő: Hogyan építsünk adatstruktúrákat a JavaScript ES6 osztályokkal?

A beillesztési módszerek összekapcsolt listagyűjteménye az egyik ok, amiért a fejlesztő úgy dönthet, hogy ezt az adatstruktúrát egy másik adatstruktúrára, például veremre használja (amely csak felülről teszi lehetővé a beillesztést és törlést).

Az Insert in the Front módszer használata

A beillesztés az elülső metódusban, ahogy a neve is sugallja, új adatokat (vagy új csomópontokat) szúr be a linkelt lista elejére.

Példa beszúrásra az elülső módszerre

Az alábbiakban egy példa látható arra, hogyan illeszthet be új adatokat a lista elejére.

//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;
}
}
}

Az insertAtFront módszer a fenti példában lehetővé teszi a felhasználó számára, hogy új csomópontokat adjon hozzá egy adott linkelt listához.

Példa a betét alkalmazására az elülső oldalon

Az alábbiakban egy példa látható arra, hogyan kell a betétet elöl alkalmazni.

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);
}
}

Az Sofőr osztály (ez az a név, amelyet gyakran a Java futtatható osztályához rendelnek), a LinkedList osztály segítségével öt páros számból álló hivatkozott listát hoz létre. Ha megnézzük a fenti kódot, könnyen belátható, hogy a „2” szám a fejlécben van a linkelt listában. De hogyan tudod ezt megerősíteni?

hogyan kell a gmailben keresni a mellékleteket

Az Összes csomópont megjelenítése módszer használata

Az összes csomópont megjelenítése módszer lényeges hivatkozott listamódszer. Enélkül a fejlesztő nem fogja látni a csomópontokat egy összekapcsolt listában. Végigjárja a linkelt listát (a fejtől kezdve), és kinyomtatja a listát alkotó minden csomópontban tárolt adatokat.

Példa az összes csomópont megjelenítésére

Az alábbiakban egy példa látható az összes megjegyzés megjelenítése módszer használatára a Java -ban.

//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();
}
}

Most, hogy a displayAllNodes módszer került hozzáadásra a LinkedList osztályban megtekintheti a linkelt listát egyetlen kódsor hozzáadásával a vezetőosztályhoz.

Példa az Összes csomópont megjelenítése módszer használatára

Az alábbiakban láthatja, hogyan használja az összes csomópont megjelenítése módszert.

//print the nodes in a linked list
List.displayAllNodes();

A fenti kódsor végrehajtása a következő kimenetet eredményezi a konzolban:

A lista:

2 4 6 8 10

A csomópont keresése módszer használata

Előfordulhatnak olyan esetek, amikor a felhasználó egy adott csomópontot szeretne megtalálni a linkelt listában.

Például nem lenne praktikus, ha egy millió millió ügyféllel rendelkező bank kinyomtatná az összes ügyfél adatait az adatbázisában, amikor csak egy adott ügyfél adatait kell látnia.

Ezért ahelyett, hogy a displayAllNodes módszer, hatékonyabb módszer a szükséges adatokat tartalmazó egyetlen csomópont megkeresése. Ezért fontos az egyetlen csomópont -módszer keresése a linkelt lista adatstruktúrájában.

Példa a csomópont keresésére

Az alábbiakban egy példa található a csomópont keresési módszer használatára.

//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;
}

A ... val displayAllNodes módszerrel megerősítette, hogy a LinkedList 5 páros számot tartalmaz 2 -től 10 -ig findNode A fenti példa megerősíti, hogy a páros számok egyike a 4 -es szám, ha egyszerűen meghívja a metódust a vezetőosztályban, és megadja a számot paraméterként.

Példa a csomópont keresése módszerre

Az alábbiakban bemutatunk egy példát arra, hogyan használhatja a find node metódust a gyakorlatban.

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

A fenti kód a következő kimenetet eredményezi a konzolban:

The node is in the list

A Csomópont törlése módszer használata

Ugyanezt a banki példát használva felülről, a bank adatbázisában lévő ügyfél esetleg bezárja a fiókját. Itt lesz hasznos a csomópont törlése módszer. Ez a legösszetettebb linkelt listamódszer.

A Csomópont törlése módszer egy adott csomópontot keres, törli azt, és összekapcsolja az előző csomópontot a törölt csomópontot követő csomóponttal.

Példa egy csomópont -módszer törlésére

Az alábbiakban egy példa a csomópont törlése módszerre.

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();
}
}

Példa a Csomópont törlése módszerre

Az alábbiakban egy példa látható a csomópont törlése módszer gyakorlatban történő használatára.

a mac os telepítése nem fejeződött be
//delete the node that holds the data 4
List.findAndDelete(4);
//print all nodes in the linked list
List.displayAllNodes();

A fenti két kódsor használata a meglévő Driver osztályban a következő kimenetet eredményezi a konzolon:

The List:
2 6 8 10

Mostantól összeállított listákat hozhat létre Java nyelven

Ha eljutott az oktató cikk végére, akkor megtanulta:

  • Csomópont -osztály létrehozása.
  • Linkelt listaosztály létrehozása.
  • Hogyan lehet feltölteni egy összekapcsolt listaosztályt az előre meghatározott módszerekkel.
  • Hogyan hozhat létre illesztőprogram osztályt, és hogyan használhatja a különböző linkelt listamódszereket a kívánt eredmény eléréséhez.

A linkelt lista csak egy a sok adatstruktúrából, amelyekkel adatokat tárolhat, kérhet és törölhet. Mivel minden megvan, amire szüksége van az induláshoz, miért nem próbálja ki ezeket a példákat saját maga Java -ban?

Részvény Részvény Csipog Email Műveletek létrehozása és végrehajtása tömbökön Java -ban

Java tanulás? Hagyja, hogy a tömbök könnyedén kezeljék adatait.

Olvassa tovább Kapcsolódó témák
  • Programozás
  • Jáva
  • Programozás
  • Kódolási tippek
A szerzőről Kadeisha Kean(21 cikk megjelent)

Kadeisha Kean Full Stack szoftverfejlesztő és műszaki/technológiai író. Megvan az a képessége, hogy leegyszerűsítse a legösszetettebb technológiai fogalmakat; olyan anyagot állít elő, amelyet minden technológiai kezdő könnyen megért. Szenvedélyesen ír, érdekes szoftvereket fejleszt és utazik a világban (dokumentumfilmeken keresztül).

Bővebben: Kadeisha Kean

Iratkozzon fel hírlevelünkre

Csatlakozz hírlevelünkhöz, ahol technikai tippeket, véleményeket, ingyenes e -könyveket és exkluzív ajánlatokat találsz!

Feliratkozáshoz kattintson ide