En introduktion till användning av länkade listor i Java

En datastruktur använder olika fördefinierade metoder för att lagra, hämta och ta bort data som kulminerar i skapandet av effektiva program. En länkad lista är en populär datastruktur, som består av en lista över noder som är anslutna (eller länkade).

Men hur skapar du en länkad lista i Java? Låt oss ta en titt.

---

---

Hur fungerar en länkad lista?

Varje länkad lista börjar med en speciell nod som ofta kallas 'huvudet', som har ansvaret att peka på listans början hela tiden. Huvudet är viktigt eftersom varje nod i en länkad lista inte behöver följa sin efterträdare fysiskt (vilket betyder att en föregångare och en efterträdare inte behöver vara fysiskt intill varandra).

Liksom varje datastruktur underlättar den länkade listan skapande, hämtning, infogning och förstörelse genom en uppsättning fördefinierade funktioner som kan användas av alla utvecklare.

Skapa en länkad lista i Java

Ett Java -program som är utformat för att skapa och manipulera länkade listor kommer att ha tre distinkta sektioner; nodklassen, den länkade listklassen och drivrutinen. Även om dessa tre sektioner kan kombineras i en fil, finns det en designprincip inom datavetenskap som kallas 'separering av problem' som varje utvecklare bör känna till.

Principen om separering av oro dikterar att varje avsnitt i koden som tar upp ett specifikt problem bör separeras. Denna princip hjälper dig att skapa renare (mer läsbar) kod och är idealisk för att skapa datastrukturer.

Det första steget för att skapa en länkad lista i Java är att skapa en nodklass. En nodklass bör ha två attribut; ett av attributen representerar nodens datadel, medan det andra attributet representerar den länkade delen. En nodklass bör också ha en konstruktör, getters och setters.

---

---

Relaterad: Lär dig hur du skapar klasser i Java

Getters och setters kommer att tillåta andra klasser (t.ex. den länkade listklassen) att komma åt de olika noder i den länkade listan.

---

---

Nodklass Exempel

Nedan följer ett exempel på en nodklass för att du ska få en uppfattning om vad vi menar:


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

I det här exemplet lagrar dataattributet heltalsvärden. Nu när du har nodklassen är det dags att gå vidare till den länkade listan.

Exempel på länkad lista

Nedan är ett exempel på en länkad lista i Java.

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


Koden ovan skapar en länkad listklass, men utan dess olika funktioner kan klassen ses som motsvarande ett tomt skal. Den länkade listans datastruktur har flera operationer som kan användas för att fylla i den:

• Insats framtill.
• Sätt i mitten.
• Insats på baksidan.

Relaterad: Hur man bygger datastrukturer med JavaScript ES6 -klasser

Den länkade listans samling av infogningsmetoder är en anledning till att en utvecklare kan välja att använda denna datastruktur framför en annan datastruktur, till exempel staplar (vilket bara tillåter infogning och radering uppifrån).

Använda skäret på den främre metoden

Insatsen längst fram, som namnet antyder, infogar nya data (eller nya noder) längst fram i den länkade listan.

Infoga vid det främre metodexemplet

Nedan är ett exempel på hur du skulle infoga ny data längst fram i listan.

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


De insertAtFront metod i exemplet ovan tillåter en användare att lägga till nya noder till en given länkad lista.

Applicera insatsen i det främre exemplet

Nedan är ett exempel på hur du skulle applicera insats på framsidan.

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


De Förare class (vilket är namnet som ofta tilldelas den körbara klassen i Java) använder klassen LinkedList för att skapa en länkad lista med fem jämna nummer. Om man tittar på koden ovan ska det vara lätt att se att siffran '2' är i toppositionen i den länkade listan. Men hur kan du bekräfta detta?

kan jag använda bluetooth -hörlurar med xbox one

Använda metoden Visa alla noder

Visa alla noder -metoden är en viktig länkad listmetod. Utan det kommer en utvecklare inte att kunna se noder i en länkad lista. Den går genom den länkade listan (från huvudet) och skriver ut data som lagras i varje nod som utgör listan.

Visa alla noder Metodexempel

Nedan är ett exempel på hur du använder metoden för att visa alla anteckningar i Java.

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

Nu när displayAllNodes metoden har lagts till i Länkad lista klass kan du visa den länkade listan genom att lägga till en enda kodrad i förarklassen.

Använda metoden Exempel på metod för visning av alla noder

Nedan ser du hur du skulle använda metoden för att visa alla noder.

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

Genom att köra raden ovan kommer följande utdata i konsolen:

Listan:

2 4 6 8 10

Använd metoden Find Node

Det kommer att finnas tillfällen när en användare vill hitta en specifik nod i en länkad lista.

Till exempel skulle det inte vara praktiskt för en bank som har miljontals kunder att skriva ut alla kunders i sin databas när de bara behöver se detaljerna för en specifik kund.

Därför istället för att använda displayAllNodes metod är en effektivare metod att hitta den enda noden som innehåller nödvändig data. Det är därför sökandet efter en enda nodmetod är viktigt i den länkade listdatastrukturen.

Hitta exempel på nodmetod

Nedan är ett exempel på hur du använder metoden Söknod.

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

Med displayAllNodes metod bekräftade du att Länkad lista innehåller 5 jämna tal från 2 till 10. The findNode exemplet ovan kan bekräfta om ett av dessa jämna nummer är siffran 4 genom att helt enkelt anropa metoden i förarklassen och ange numret som en parameter.

Använda exempel på Find Node Method

Nedan följer ett exempel på hur du skulle använda metoden Söknod i praktiken.

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


Koden ovan ger följande utdata i konsolen:

The node is in the list

Använd metoden Ta bort en nod

Med samma bankexempel ovan kan en kund i bankens databas vilja stänga sitt konto. Det är här metoden för att ta bort en nod kommer att vara användbar. Det är den mest komplexa länkade listmetoden.

Metoden Ta bort en nod söker efter en given nod, tar bort den noden och länkar den föregående noden till den som följer noden som har tagits bort.

Ta bort ett exempel på nodmetod

Nedan följer ett exempel på metoden delete a node.

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

Använda exemplet Ta bort en nodmetod

Nedan är ett exempel på hur du använder delete a node -metoden i praktiken.

kan inte se extern hårddisk

//delete the node that holds the data 4
List.findAndDelete(4);
//print all nodes in the linked list
List.displayAllNodes();

Om du använder de två kodraderna ovan i den befintliga förarklassen kommer följande utdata att visas i konsolen:

The List:
2 6 8 10

Nu kan du skapa länkade listor i Java

Om du tog dig till slutet av den här självstudieartikeln har du lärt dig:

• Hur man skapar en nodklass.
• Hur man skapar en länkad listklass.
• Hur man fyller i en länkad listklass med sina fördefinierade metoder.
• Hur man skapar en förarklass och använder de olika länkade listmetoderna för att uppnå önskat resultat.

En länkad lista är bara en av många datastrukturer som du kan använda för att lagra, hämta och ta bort data. Eftersom du har allt du behöver för att komma igång, varför inte prova dessa exempel själv i Java?

Dela med sig Dela med sig Tweet E-post Hur man skapar och utför operationer på matriser i Java

Lär dig Java? Låt matriser hantera dina data med lätthet.

Läs Nästa Relaterade ämnen

• Programmering
• Java
• Programmering
• Kodningstips

Om författaren Kadeisha Kean(21 artiklar publicerade)

Kadeisha Kean är en fullstack mjukvaruutvecklare och teknisk/teknikförfattare. Hon har den distinkta förmågan att förenkla några av de mest komplexa tekniska begreppen; producerar material som lätt kan förstås av någon nybörjare inom teknik. Hon brinner för att skriva, utveckla intressant programvara och resa runt i världen (genom dokumentärer).

Mer från Kadeisha Kean

Prenumerera på vårt nyhetsbrev

Gå med i vårt nyhetsbrev för tekniska tips, recensioner, gratis e -böcker och exklusiva erbjudanden!

Klicka här för att prenumerera