doubly linked list java implementation code examples
Denna handledning förklarar den dubbelt länkade listan i Java tillsammans med implementeringen av dubbel länkad lista, cirkulär dubblerad länkad Java-kod och exempel:
Den länkade listan är en sekventiell representation av element. Varje element i den länkade listan kallas en 'nod'. En typ av länkad lista kallas ”Singly linked list”.
I detta innehåller varje nod en datadel som lagrar faktiska data och en andra del som lagrar pekaren till nästa nod i listan. Vi har redan lärt oss detaljerna i den enskilt länkade listan i vår tidigare handledning.
=> Kontrollera ALLA Java-handledning här.
Vad du kommer att lära dig:
Dubbel länkad lista i Java
En länkad lista har en annan variant som kallas 'dubbelt länkad lista'. En dubbelt länkad lista har en ytterligare pekare som kallas föregående pekare i sin nod bortsett från datadelen och nästa pekare som i den enskilt länkade listan.
En nod i den dubbelt länkade listan ser ut som följer:
vilka är de bästa apparna för virtuell verklighet
Här är 'Före' och 'Nästa' pekare till föregående respektive nästa element i noden. ”Data” är det faktiska elementet som lagras i noden.
Följande bild visar en dubbelt länkad lista.
Ovanstående diagram visar den dubbelt länkade listan. Det finns fyra noder i den här listan. Som du kan se är den föregående pekaren i den första noden och nästa pekare i den sista noden inställd på noll. Den tidigare pekaren inställd på null indikerar att detta är den första noden i den dubbelt länkade listan medan nästa pekare som är satt till null anger att noden är den sista noden.
Fördelar
- Eftersom varje nod har pekare som pekar på föregående och nästa noder kan den dubbelt länkade listan korsas enkelt framåt och bakåt.
- Du kan snabbt lägga till den nya noden bara genom att ändra pekare.
- På samma sätt är borttagningen enklare för borttagning eftersom vi har både tidigare och nästa pekare och vi behöver inte gå igenom hela listan för att hitta den tidigare noden som i fallet med den enskilt länkade listan.
Nackdelar
- Eftersom det finns en extra pekare i den dubbelt länkade listan, dvs. den föregående pekaren, krävs ytterligare minnesutrymme för att lagra denna pekare tillsammans med nästa pekare och dataobjekt.
- Alla operationer som tillägg, radering etc. kräver att både föregående och nästa pekare manipuleras och därmed inför operativa omkostnader.
Implementering i Java
Implementeringen av en dubbelt länkad lista i Java består av att skapa en dubbellänkad listklass, nodklassen och lägga till noder till den dubbelt länkade listan
Tillägget av nya noder görs vanligtvis i slutet av listan. Nedanstående diagram visar tillägget av den nya noden i slutet av den dubbelt länkade listan.
Som visas i ovanstående diagram, för att lägga till en ny nod i slutet av listan, pekar nästa pekare i den sista noden nu till den nya noden istället för null. Den tidigare pekaren i den nya noden pekar på den sista noden. Nästa pekare i den nya noden pekar också på null, vilket gör den till en ny sista nod.
Programmet nedan visar Java-implementering av en dubbelt länkad lista med tillägg av nya noder i slutet av listan.
class DoublyLinkedList { //A node class for doubly linked list class Node{ int item; Node previous; Node next; public Node(int item) { this.item = item; } } //Initially, heade and tail is set to null Node head, tail = null; //add a node to the list public void addNode(int item) { //Create a new node Node newNode = new Node(item); //if list is empty, head and tail points to newNode if(head == null) { head = tail = newNode; //head's previous will be null head.previous = null; //tail's next will be null tail.next = null; } else { //add newNode to the end of list. tail->next set to newNode tail.next = newNode; //newNode->previous set to tail newNode.previous = tail; //newNode becomes new tail tail = newNode; //tail's next point to null tail.next = null; } } //print all the nodes of doubly linked list public void printNodes() { //Node current will point to head Node current = head; if(head == null) { System.out.println('Doubly linked list is empty'); return; } System.out.println('Nodes of doubly linked list: '); while(current != null) { //Print each node and then go to next. System.out.print(current.item + ' '); current = current.next; } } } class Main{ public static void main(String[] args) { //create a DoublyLinkedList object DoublyLinkedList dl_List = new DoublyLinkedList(); //Add nodes to the list dl_List.addNode(10); dl_List.addNode(20); dl_List.addNode(30); dl_List.addNode(40); dl_List.addNode(50); //print the nodes of DoublyLinkedList dl_List.printNodes(); } }
Produktion:
Noder med dubbelt länkad lista:
10 20 30 40 50
Förutom att lägga till en ny nod i slutet av listan kan du också lägga till en ny nod i början av listan eller mellan listan. Vi överlåter denna implementering till läsaren så att läsarna kan förstå operationerna på ett bättre sätt.
Cirkulär dubbelt länkad lista i Java
En cirkulär dubbelt länkad lista är en av de komplexa strukturerna. I den här listan innehåller den sista noden i den dubbelt länkade listan adressen till den första noden och den första noden innehåller adressen till den sista noden. Således finns det i en cirkulär dubbelt länkad lista en cykel och ingen av nodpekarna är inställd på null.
Följande diagram visar den cirkulära dubbelt länkade listan.
Som visas i ovanstående diagram pekar nästa pekare på den sista noden till den första noden. Den tidigare pekaren i den första noden pekar på den sista noden.
Cirkulärt dubbelt länkade listor har breda applikationer inom programvaruindustrin. En sådan applikation är den musikaliska appen som har en spellista. I spellistan, när du har spelat upp alla låtarna och sedan i slutet av den sista låten, går du automatiskt tillbaka till den första låten. Detta görs med cirkulära listor.
Fördelar med en cirkulär dubbel länkad lista:
- Den cirkulära dubbelt länkade listan kan passeras från huvud till svans eller svans till huvud.
- Att gå från huvud till svans eller svans till huvud är effektivt och tar bara konstant tid O (1).
- Den kan användas för att implementera avancerade datastrukturer inklusive Fibonacci-heap.
Nackdelar:
- Eftersom varje nod behöver göra plats för den föregående pekaren krävs extra minne.
- Vi måste hantera många pekare när vi utför operationer på en cirkulär dubbelt länkad lista. Om pekare inte hanteras ordentligt kan implementeringen gå sönder.
Nedanstående Java-program visar implementeringen av den cirkulär dubbelt länkade listan.
import java.util.*; class Main{ static Node head; // Doubly linked list node definition static class Node{ int data; Node next; Node prev; }; // Function to insert node in the list static void addNode(int value) { // List is empty so create a single node furst if (head == null) { Node new_node = new Node(); new_node.data = value; new_node.next = new_node.prev = new_node; head = new_node; return; } // find last node in the list if list is not empty Node last = (head).prev; //previous of head is the last node // create a new node Node new_node = new Node(); new_node.data = value; // next of new_node will point to head since list is circular new_node.next = head; // similarly previous of head will be new_node (head).prev = new_node; // change new_node=>prev to last new_node.prev = last; // Make new node next of old last last.next = new_node; } static void printNodes() { Node temp = head; //traverse in forward direction starting from head to print the list while (temp.next != head) { System.out.printf('%d ', temp.data); temp = temp.next; } System.out.printf('%d ', temp.data); //traverse in backward direction starting from last node System.out.printf('
Circular doubly linked list travesed backward:
'); Node last = head.prev; temp = last; while (temp.prev != last) { System.out.printf('%d ', temp.data); temp = temp.prev; } System.out.printf('%d ', temp.data); } public static void main(String[] args) { //the empty list Node l_list = null; // add nodes to the list addNode(40); addNode(50); addNode(60); addNode(70); addNode(80); //print the list System.out.printf('Circular doubly linked list: '); printNodes(); } }
Produktion:
Cirkulär dubbelt länkad lista: 40 50 60 70 80
Cirkulär dubbelt länkad lista förflyttas bakåt:
80 70 60 50 40
I ovanstående program har vi lagt till noden i slutet av listan. När listan är cirkulär, när den nya noden läggs till, kommer nästa pekare i den nya noden att peka på den första noden och den tidigare noden i den första noden pekar på den nya noden.
På samma sätt kommer den föregående pekaren i den nya noden att peka på den aktuella sista noden som nu blir den näst sista noden. Vi lämnar implementeringen av att lägga till en ny nod i början av listan och mellan noderna till läsarna.
Vanliga frågor
F # 1) Kan den dubbelt länkade listan vara cirkulär?
Svar: Ja. Det är en mer komplex datastruktur. I en cirkulär dubbelt länkad lista innehåller den föregående pekaren i den första noden adressen till den sista noden och nästa pekare i den sista noden innehåller adressen till den första noden.
F # 2) Hur skapar du en dubbelt cirkulär länkad lista?
Svar: Du kan skapa en klass för en dubbelt cirkulär länkad lista. Inuti denna klass kommer det att finnas en statisk klass som representerar noden. Varje nod innehåller två pekare - föregående och nästa och ett dataobjekt. Då kan du göra åtgärder för att lägga till noder i listan och för att korsa listan.
F # 3) Är dubbelt länkad linjär eller cirkulär?
Svar: Den dubbelt länkade listan är en linjär struktur men en cirkulär dubbelt länkad lista som har sin svans riktad mot huvudet och huvudet riktad mot svansen. Därför är det en cirkulär lista.
F # 4) Vad är skillnaden mellan den dubbelt länkade listan och den cirkulär länkade listan?
Svar: En dubbelt länkad lista har noder som håller information om dess tidigare såväl som nästa noder med hjälp av föregående respektive nästa pekare. Den föregående pekaren i den första noden och nästa pekaren i den sista noden är också satt till null i den dubbelt länkade listan.
I den cirkulära länkade listan finns det inga start- eller slutnoder och noderna bildar en cykel. Ingen av pekarna är också inställd på null i den cirkulära länkade listan.
topp mp3 musik nedladdare för android
F # 5) Vilka är fördelarna med en dubbelt länkad lista?
Svar: Fördelarna med den dubbelt länkade listan är:
- Den kan korsas både framåt och bakåt.
- Insättning är lättare eftersom vi inte behöver gå igenom hela listan för att hitta det tidigare elementet.
- Radering är effektiv eftersom vi vet att tidigare och nästa noder och manipulering är enklare.
Slutsats
I denna handledning diskuterade vi den dubbelt länkade listan i Java i detalj. En dubbelt länkad lista är en komplex struktur där varje nod innehåller pekare till dess tidigare såväl som nästa noder. Hanteringen av dessa länkar är ibland svår och kan leda till uppdelning av kod om den inte hanteras ordentligt.
Sammantaget är operationerna för en dubbelt länkad lista mer effektiva eftersom vi kan spara tid för att korsa listan eftersom vi har både föregående och nästa pekare.
Den cirkulära dubbelt länkade listan är mer komplex och de bildar ett cirkulärt mönster med den föregående pekaren i den första noden som pekar på den sista noden och nästa pekare i den sista noden som pekar på den första noden. I det här fallet är också operationerna effektiva.
Med detta är vi klara med den länkade listan i Java. Håll koll på många fler självstudier om sök- och sorteringstekniker i Java.
=> Besök här för den exklusiva Java-utbildningsserien.
Rekommenderad läsning
- Dubbelt länkad datastruktur i C ++ med illustration
- Binär sökalgoritm i Java - Implementering och exempel
- Java List - Hur man skapar, initialiserar och använder en lista i Java
- Java-gränssnitt och abstrakt klasshandledning med exempel
- Java-listmetoder - Sortera lista, innehåller, Lägg till lista, ta bort lista
- Insertion Sort In Java - Insertion Sort Algorithm & Exempel
- JAVA-handledning för nybörjare: 100+ praktiska Java-videohandledning
- Bubblesortering i Java - Java-sorteringsalgoritmer och kodexempel