Länkad lista i Java - länkad listaimplementering och Java-exempel

linked list java linked list implementation java examples

Prova Vårt Instrument För Att Eliminera Problem

Välj Operativsystemet Välj Ett Projektprogram (Valfritt)

Beskriv Ditt Problem

Denna handledning förklarar vad som är en länkad datastruktur i Java och hur man skapar, initierar, implementerar, går igenom, reverserar och sorterar en Java-länkad lista:

I Java är en LinkedList en datastruktur som lagrar element på en icke-sammanhängande plats. Det är en linjär datastruktur.

Varje datapost kallas en 'nod' och varje nod har en datadel och en adressdel. Adressdelen lagrar länken till nästa nod i LinkedList.

=> Besök här för att se Java Training Series för alla.

Länkad lista i Java

Vad du kommer att lära dig:

LinkedList I Java
Slutsats
- Rekommenderad läsning

LinkedList I Java

Nedan följer den allmänna layouten för LinkedList:

allmän layout för LinkedList

Som visas i ovanstående representation av LinkedList är varje objekt i LinkedList 'nod'. Varje nod har två delar, den första delen lagrar data och den andra delen har en referens eller pekare eller adress till nästa nod i LinkedList.

bästa registerrensaren för Windows 7 64 bitar

Detta arrangemang är nödvändigt eftersom data i LinkedList lagras på icke-angränsande platser, till skillnad från Arrays.

“Huvudet” för LinkedList är en pekare som innehåller adressen till det första elementet i LinkedList. Den sista noden i LinkedList är svansen. Som visas i figuren ovan är adressdelen av den sista noden i LinkedList inställd på 'Null' som indikerar slutet på LinkedList.

Ovanstående diagram representerar en ” Singlistad lista ”Som lagrar adressen till bara nästa nod i LinkedList.

Det finns en annan version som kallas “ Dubbel länkad lista ”Vars nod har tre delar:

Adress eller referens eller pekare till föregående element i LinkedList.
Datadel
Adress eller referens eller pekare till nästa element i LinkedList.

Den tidigare adressen till det första elementet i LinkedList kommer att ställas in till Null medan nästa pekare för det sista elementet i LinkedList är inställt på Null.

Representation av dubbelt länkad lista:

dubbelt länkad lista

Som visas i ovanstående representation har varje nod i den dubbelt länkade listan pekare till sin tidigare och nästa nod (sålunda representerad utan pilar). Den föregående pekaren i den första noden pekar på noll medan nästa pekare i den sista noden pekar på noll.

I denna LinkedList-handledning behandlar vi mestadels listan som är länkade. Vi kommer att diskutera den dubbelt länkade listan i vår nästa handledning.

Java LinkedList-klass

I Java implementeras den länkade listan av “ Länkad lista ' klass. Denna klass tillhör ” java.util ”Paket. LinkedList-klassen implementerar gränssnitt List och Deque och ärver klassen AbstractList.

Nedan visas klasshierarkin för klassen LinkedList.

klasshierarki för klassen LinkedList

Ovanstående diagram visar hierarkin för klassen LinkedList. Som visas implementerar klassen LinkedList gränssnitten List och Deque.

Som redan nämnts är LinkedList-klassen en del av ” java.util ”Paket. Därför bör du kunna använda klassen LinkedList i ditt program genom att inkludera ett av följande påståenden i ditt program.

import java.util.*;

Eller

import java.util.LinkedList;

Så baserat på ovanstående hierarki är en typisk definition av LinkedList-klassen följande:

public class LinkedList extends AbstractSequentialList implements List, Deque, Cloneable, Serializable

Nedan listas några av egenskaperna för klassen LinkedList som du bör komma ihåg:

Denna klass är inte synkroniserad.
Det tillåter dubbla värden.
Behåller infogningsordningen.
Eftersom det inte krävs att element flyttas medan de rör sig är manipuleringen av element i den snabbare.
Denna klass kan användas för att implementera en stack, kö och lista.

Hur man skapar en länkad lista i Java

Innan vi går vidare till att skapa en länkad lista i Java, ska vi först diskutera en länkad listnod i Java.

Som redan diskuterats består en länkad lista av noder. Således kan vi i Java representera en LinkedList som en klass med dess nod som en separat klass. Därför kommer denna klass att ha en hänvisning till nodtypen.

Detta visas som nedan:

class LinkedList { Node head; // list head //node - linkedlist class Node { int data; Node next; Node(int d) { data = d; } //constructor to create a new node } }

För att skapa ett objekt av typen LinkedList finns det två huvudkonstruktörer enligt följande:

# 1) LinkedList ()

Den allmänna syntaxen för denna konstruktör är:

LinkedList linkedList = new LinkedList();

Ovanstående uttalande skapar en tom LinkedList.

Till exempel,

LinkedList l_list = new LinkedList();

Detta skapar en tom länkad lista med namnet l_list.

# 2) LinkedList (samling c)

Den allmänna syntaxen är:

LinkedList linkedList = new LinkedList (Collection c);

Ovanstående uttalande skapar en LinkedList med element från samlingen c som dess inledande element.

Liksom andra listdatastrukturer som vi redan har sett kan den länkade listan också initieras med hjälp av add-metoden, Arrays.asList () -metoden eller genom att använda konstruktören med samlingen som ett argument.

Länkad implementering i Java

Nedan följer ett enkelt exempel på en LinkedList-datastruktur i Java. I detta exempel på implementering kommer vi att använda metoden add och asList för att initialisera LinkedList-objekten.

import java.util.*; public class Main{ public static void main(String() args) { //create a LinkedList object and initialize it with Array elements converted to list LinkedList  intList = new LinkedList<>(Arrays.asList(10,20,30,40,50)); //print the LinkedList just created System.out.println('Contents of first LinkedList: ' + intList); //create an empty list LinkedList colorsList = new LinkedList<>(); //add elements to the linkedList using add method. colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('Cyan'); colorsList.add('Magenta'); // print the LinkedList System.out.println('
Contents of second LinkedList: ' + colorsList); } }

Produktion:

Innehållet i den första LinkedList: (10, 20, 30, 40, 50)
Innehållet i den andra LinkedList: (Röd, grön, blå, cyan, magenta)

outputlänkad implementering av listan

Ovanstående program visar skapandet och initialiseringen av LinkedList. Först skapar vi en LinkedList av typen Integer och tillhandahåller en array med heltal konverterade till lista med asList-metoden som initialvärden för LinkedList.

Därefter skapar vi en tom LinkedList av typen String och sedan använder vi metoden add, vi lägger till värden i LinkedList.

Slutligen visar vi båda LinkedList-objekten som en sträng.

Traversera / skriv ut länkad lista i Java

För att skriva ut innehållet eller utföra några åtgärder på elementen i LinkedList måste du gå igenom dess element. Vi har redan sett dessa metoder i våra tidigare handledning. I det här avsnittet kommer vi att diskutera exemplen på var och en med avseende på LinkedList.

Använder för loop

import java.util.LinkedList; class Main { public static void main(String() args) { // Create a LinkedList and initialize it LinkedList colorList = new LinkedList<>(); colorList.add('Red'); colorList.add('Green'); colorList.add('Blue'); // Using for loop,print the contents of the LinkedList System.out.println('LinkedList elements using for loop:'); for(int i=0; i  Produktion: 
 LinkedList-element som använder för loop: 
Röd grön blå
  
 Använda forEach Loop
import java.util.LinkedList; class Main { public static void main(String() args) { // Create a LinkedList and initialize it LinkedList colorList = new LinkedList<>(); colorList.add('Red'); colorList.add('Green'); colorList.add('Blue'); // Using forEach loop,print the contents of the LinkedList System.out.println('LinkedList elements using forEach loop:'); for(String color:colorList) { System.out.print(color + ' '); } } }  Produktion: 
 LinkedList-element som använder forEach loop: 
Röd grön blå
  
 Använda Iterator
import java.util.*; public class Main{ public static void main(String args()){ //declare a LinkedList object LinkedList l_list=new LinkedList(); //Add elements to LinkedList l_list.add('Red'); l_list.add('Green'); l_list.add('Blue'); l_list.add('Yellow'); //declare an iterator for the LinkedList Iterator itr=l_list.iterator(); System.out.println('The contents of Linked List:'); //Iterate through the LinkedList using Iterator and print its elements while(itr.hasNext()){ System.out.print(itr.next() + ' '); } } }  Produktion: 
 Innehållet i länkad lista: 
Röd grön blå gul
qa leda intervjufrågor och svar pdf
  
 LinkedList-metoder
 LinkedList-klassen tillhandahåller API som stöder olika metoder för att manipulera den länkade listan. Vi har tabelliserat metoderna i LinkedList API nedan.
  Vi kommer att diskutera de viktigaste operationerna / metoderna i följande avsnitt. 
   Metod Prototyp Beskrivning  
 
  Klar ogiltig rensa () Raderar alla element från listan.  
 Lägg till boolesk tillsats (E e) Lägg till ett angivet element i den LinkedList  
  void add (int index, E element) Lägg till element vid det angivna indexet i LinkedList  
  Lägg till alla boolean addAll (Collection c) Lägger till elementen i den givna samlingen c i slutet av LinkedList.  
  boolean addAll (int index, Collection c) Lägger till elementen i den givna samlingen c vid det angivna indexet i LinkedList  
  addFirst ogiltig addFirst (E e) Lägg till det givna elementet som det första elementet i LinkedList.  
  addLast ogiltig addLast (E e) Lägg till det givna elementet i slutet av listan.  
   Klona Objektklon () Skapar en grunt kopia av LinkedList  
  Innehåller Boolean innehåller (Objekt o) Kontrollerar om listan innehåller angivna element; om ja returnerar sant.  
  fallandeIterator Iterator fallandeIterator () Returnerar en omvänd ordnad iterator för LinkedList.  
  Element E-element () Returnerar elementet i början av listan.  
  Skaffa sig E get (int index) Hämtar elementet till det angivna indexet.  
  getFirst E getFirst () Hämtar det första elementet i LinkedList.  
  getLast E getLast () Hämtar det sista elementet i LinkedList.  
  index för Int indexOf (Objekt o) Hitta index för den första förekomsten av de angivna elementen i listan och returnera indexet. -1 om element inte hittades.  
  lastIndexOf Int lastIndexOf (Objekt o) Returnerar positionen för den senaste förekomsten av det givna elementet i LinkedList; -1 om givna element inte finns  
  listIterator ListIterator listIterator (int index) Returnerar listIterator från det angivna indexet i den länkade listan.  
  Erbjudande booleskt erbjudande (E e) Lägger till det givna elementet som det sista elementet (svansen) i LinkedList.  
  offerFirst Boolean offerFirst (E e) Lägger till det givna elementet som det första elementet i LinkedList.  
  offerLast Boolean offerLast (E e) Lägg till givet element e i slutet av LinkedList.  
  Titt E titt () Returnerar huvudet på listan utan att ta bort den.  
  kikaFörst E peekFirst () Returnerar det första elementet i listan. returnerar null om listan är tom.  
  peekLast E peekLast () Returnerar det sista elementet eller null om listan är tom. Elementet raderas inte.  
  Opinionsundersökning E-undersökning () Returnerar huvudet på LinkedList och tar också bort det.  
  pollFirst E pollFirst () Returnerar och tar bort det första elementet i listan; returnerar null om listan är tom.  
  pollLast E pollLast () Returnerar och tar bort det sista elementet i listan; returnerar null om listan är tom.  
  Pop E pop () Popsar elementet från staplingsrepresentationen för LinkedList.  
  Skjuta på Ogiltigt tryck (E e) Skjuter eller infogar ett element i staplingsrepresentationen för LinkedList.  
  Ta bort E ta bort () Tar bort och returnerar huvudet på LinkedList.  
  E ta bort (int index) Tar bort elementet vid det angivna indexet från LinkedList.  
  boolean ta bort (Objekt o) Tar bort den första förekomsten av det givna elementet från LinkedList.  
  ta bortFörsta E removeFirst () Returnerar och tar bort det första elementet från listan.  
  removeFirstOccurence boolean removeFirstOccurrence (Objekt o) Raderar den första förekomsten av det givna elementet från listan när listan passeras från huvud till svans.  
  ta bort förra E removeLast () Returnerar det sista elementet i LinkedList och raderar det också.  
  ta bortLastOccurence boolean removeLastOccurrence (Objekt o) Tar bort den sista förekomsten av det givna elementet från LinkedList när den passeras från huvud till svans  
  Uppsättning E-uppsättning (int-index, E-element) Ställer in det angivna elementet vid det angivna indexet. Ersätter det aktuella elementet med nytt.  
  Storlek Int storlek () Returnerar storlek eller antal element i LinkedList  
  toArray Objekt () toArray () Konverterar LinkedList till en matris som innehåller alla listelement i rätt ordning  
  T () toArray (T () a) Konverterar LinkedList till en array med runtime-typ samma som argument a.  
 
 
  Nedanstående Java-program visar de olika metoderna som vi listade ovan. 
import java.util.*; public class Main { public static void main(String args()) { //create a linked list LinkedList l_list = new LinkedList(); // Add elements to linkedList using various add methods l_list.add('B'); l_list.add('C'); l_list.addLast('G'); l_list.addFirst('A'); l_list.add(3, 'D'); l_list.add('E'); l_list.add('F'); //print the linkedList System.out.println('Linked list : ' + l_list); //Create and initialize an ArrayList ArrayList aList = new ArrayList<>(); aList.add('H'); aList.add('I'); //add the ArrayList to linkedList using addAll method l_list.addAll(aList); //print the linkedList System.out.println('Linked list after adding ArrayList contents: ' + l_list); // use various remove methods to remove elements from linkedList l_list.remove('B'); l_list.remove(3); l_list.removeFirst(); l_list.removeLast(); //print the altered list System.out.println('Linked list after deletion: ' + l_list); // use contains method to check for an element in the linkedList boolean ret_value = l_list.contains('G'); //print the results of contains method if(ret_value) System.out.println('List contains the element 'G' '); else System.out.println('List doesn't contain the element 'G''); // use size methods to return Number of elements in the linked list int size = l_list.size(); System.out.println('Size of linked list = ' + size); // Get and set elements from linked list Object element = l_list.get(3); System.out.println('Element returned by get() : ' + element); l_list.set(3, 'J'); System.out.println('Linked list after change : ' + l_list); //convert linkedList to Array using toArray methods String () list_array = l_list.toArray(new String(l_list.size())); System.out.println('Array obtained from linked List:' + Arrays.toString(list_array)); } } Produktion: 
 Länkad lista: (A, B, C, D, G, E, F) 
Länkad lista efter att ha lagt till ArrayList-innehåll: (A, B, C, D, G, E, F, H, I) 
Länkad lista efter radering: (C, D, E, F, H) 
Listan innehåller inte elementet 'G' 
Storlek på länkad lista = 5 
Element returneras av get (): F 
Länkad lista efter ändring: (C, D, E, J, H) 
Array erhållen från länkad lista: (C, D, E, J, H)
  
 Ovanstående program visar olika metoder för LinkedList-klassen. Först förklarar vi en LinkedList av typen String. Sedan använder vi olika versioner av add-metoden som add, andFirst, addLast, addAll, etc. för att fylla i LinkedList med värden.
 Här kan vi lägga till elementet direkt i slutet av listan eller lägga till elementet på en angiven position i listan.
 Vi använder också metoden addFirst för att lägga till ett element i början av listan och addLast för att lägga till ett element i slutet av listan. Sedan utför vi borttagningsåtgärder på LinkedList som remove, removeFirst, removeLast, etc.
 För borttagningsmetoden kan vi antingen ange det element som ska tas bort eller så kan vi ange indexet eller positionen i den LinkList där elementet ska tas bort. Metoderna removeFirst och removeLast tar bort det första och det sista elementet i listan.
 Sedan söker vi i listan efter ett visst element med metoden innehåller. Därefter använder vi storleken () -metoden för att hämta storleken eller längden på LinkedList. Sedan använder vi get / set-metoder för att hämta värdet vid ett visst index i listan och sedan ersätta ett värde på en viss position i listan.
  Slutligen konverterar vi LinkedList till en Array med toArray-metoden. 
 Omvänd länkad lista i Java
 För att vända en länkad lista i Java använder vi metoden “descendingIterator ()” som returnerar en omvänd iterator för listan. Vi kan sedan använda denna iterator för att gå igenom listan och visa element.
  Programmet nedan omvandlar den länkade listan med hjälp av metoden descendingIterator (). 
import java.util.*; public class Main{ public static void main(String args()){ //create a LinkedList object LinkedList l_list=new LinkedList(); l_list.add('Pune'); l_list.add('Mumbai'); l_list.add('Nagpur'); System.out.println('Linked List : ' + l_list); System.out.println('Linked List in reverse order:'); //use descendingIterator method to get a reverse iterator Iterator iter=l_list.descendingIterator(); //traverse the list using iterator and print the elements. while(iter.hasNext()) { System.out.print(iter.next() + ' '); } } }  Produktion: 
 Länkad lista: (Pune, Mumbai, Nagpur) 
Länkad lista i omvänd ordning: 
Nagpur Mumbai Pune
  
 I ovanstående program förklarar vi en länkad lista och skriver sedan ut den. Sedan får vi en omvänd iterator och går sedan igenom listan med den och visar varje element. Utgången visar det länkade listinnehållet, först i den ordning elementen läggs till och sedan visar utgången innehållet i omvänd ordning.
 Sortera en länkad lista i Java
 LinkedList-klassobjekt kan sorteras med metoden Collections.sort (). Denna metod ger två versioner med eller utan att använda en komparator. När metoden Collections.sort () anropas utan en jämförare sorteras samlingen i den naturliga ordningen.
 När jämförare används med den här metoden kan vi definiera våra egna sorteringskriterier genom att åsidosätta metoden jämför till.
  Nedanstående Java-program sorterar en LinkedList med hjälp av Collections.sort (). Här sorterar vi matriser med naturlig ordning och med hjälp av en komparator. 
import java.util.*; public class Main{ public static void main(String args()) { // create and initialize the LinkedList object LinkedList l_list = new LinkedList<>(); l_list.add('Jan'); l_list.add('Feb'); l_list.add('Mar'); l_list.add('Apr'); l_list.add('May'); l_list.add('Jun'); //print original unsorted linkedlist System.out.println('Original LinkedList (unsorted): ' + l_list); // sort LinkedList with Collecitons.sort() method in natural order Collections.sort(l_list); System.out.println('
LinkedList (sorted in natural order): ' + l_list); // sort LinkedList using Collection.sort() and Comparator in Java Collections.sort(l_list, new Comparator() { @Override public int compare(String s1, String s2) { return s1.length() - s2.length(); } } ); System.out.println('LinkedList (sorted using Comparator): ' + l_list); } } Produktion: 
 Original LinkedList (osorterat): (Jan, Feb, Mar, Apr, May, Jun) 
LinkedList (sorterad i naturlig ordning): (Apr, Feb, Jan, Jun, Mar, May) 
LinkedList (sorterad med Comparator): (Apr, Feb, Jan, Jun, Mar, May)
  
 Ta bort dubbletter
 För att ta bort dubbletter måste du korsa varje nod och jämföra den med nästa nod. Om båda noder är desamma hoppar vi över en nod och flyttar till nästa.
 På det här sättet, efter att ha korsat varje nod och blivit av med dubbla noder, får vi den resulterande listan utan några dubbletter.
  Nedan finns ett Java-program för att ta bort dubbletter. 
class LinkedList_Duplicate { //A class to represent node in linkedlist class Node{ int data; Node next; public Node(int data) { this.data = data; this.next = null; } } //Initially the head and tail of the linked list set to null public Node head = null; public Node tail = null; //add a new node to the linkedlist public void addNode(int data) { //Create new node Node newNode = new Node(data); //If list is empty set head and tail to new node if(head == null) { head = newNode; tail = newNode; } else { // add newNode after the tail tail.next = newNode; //newNode is now the tail or last element tail = newNode; } } //scans the linkedlist and removes duplicate nodes public void removeDuplicateNodes() { //Head is the current node Node current = head, index = null, temp = null; //head = null means list is empty if(head == null) { return; } //traverse through the list else { while(current != null){ //temp node points to previous node to index. temp = current; //Index will point to node next to current index = current.next; while(index != null) { //Check if current node's data is equal to index node's data if(current.data == index.data) { //since node is duplicate skip index and point to next node temp.next = index.next; } else { //Temp will point to previous node of index. temp = index; } index = index.next; } current = current.next; } } } //print the linked list public void print() { //Node current will point to head Node current = head; if(head == null) { System.out.println('List is empty'); return; } while(current != null) { //Print each node by incrementing pointer System.out.print(current.data + ' '); current = current.next; } System.out.println(); } }class Main{ public static void main(String() args) { LinkedList_Duplicate l_List = new LinkedList_Duplicate(); //Add data to the list l_List.addNode(1); l_List.addNode(1); l_List.addNode(2); l_List.addNode(3); l_List.addNode(5); l_List.addNode(2); l_List.addNode(1); l_List.addNode(1); //print the original list System.out.println('Original Linkedlist: '); l_List.print(); //Removes duplicate nodes l_List.removeDuplicateNodes(); //print the altered list without duplicates System.out.println('LinkedList after removing duplicates: '); l_List.print(); } }  Produktion: 
 Ursprunglig länkad lista: 
1 1 2 3 5 2 1 1 
LinkedList efter borttagning av dubbletter: 
1 2 3 5
  
 I ovanstående program har vi skapat en länkad listklass för att ta bort dubbletter. Vi har också en klass för att definiera varje nod. Med andra ord är noderna i listan objekt för denna klassnod. Vi har en metod för att lägga till noden i en länkad lista.
 Sedan i removeDuplicate-metoden går vi igenom varje nod i den länkade listan med start från huvudet och jämför varje efterföljande nod för duplikatet. Om en duplikat hittas hoppar vi över den noden och fortsätter till nästa nod.
 På så sätt byggs ist genom att hoppa över dubbletterna och den ändrade listan skrivs ut med utskriftsmetoden ().
 Cirkulär länkad lista i Java
 En cirkulär länkad lista är en lista som har sin svans eller sista nod ansluten till huvudet eller den första noden.
  Nedanstående diagram visar den cirkulära länkade listan i Java. 
  
 Som visas i ovanstående diagram är adressdelen av den sista noden eller svansen i den länkade listan inte satt till null. Istället pekar den tillbaka till den första noden eller huvudet på listan och bildar därmed en cirkulär länkad lista.
  Programmet nedan implementerar en cirkulär länkad lista där vi måste manipulera enskilda noder i den länkade listan. 
 class CircularLinkedList { //Node definition for circular linked list public class Node{ int data; Node next; public Node(int data) { this.data = data; } } //Initially head and tail pointers point to null public Node head = null; public Node tail = null; //add new node to the circular linked list public void add(int data){ //Create new node Node newNode = new Node(data); //check if list is empty if(head == null) { //head and tail point to same node if list is empty head = newNode; tail = newNode; newNode.next = head; } else { //tail points to new node if list is not empty tail.next = newNode; //New node becomes new tail. tail = newNode; //tail points back to head tail.next = head; } } //Display the nodes in circular linked list public void displayList() { Node current = head; if(head == null) { System.out.println('The List is empty'); } else { System.out.println('Circular linked list nodes: '); do{ //Print each node of the linked list System.out.print(current.data + ' '); current = current.next; }while(current != head); System.out.println(); } } } class Main{ public static void main(String() args) { //create a CircularLinkedList object CircularLinkedList c_list = new CircularLinkedList(); //Add data to the list c_list.add(10); c_list.add(20); c_list.add(30); c_list.add(40); //Display the nodes in circular linked list c_list.displayList(); } }  Produktion: 
 Cirkulär länkade listnoder: 
10 20 30 40
  
 Java 8 LinkedList
 Även om det inte finns några fler funktioner som läggs till specifikt till LinkedList-klassen i Java 8, introducerade den ändå strömmar för att manipulera data.
  Programmet nedan visar användningen av Java 8-ström för att visa LinkedList. 
import java.util.LinkedList; import java.util.List; public class Main { public static void main(String() args) { //create a LinkedList and initialize it to values List colorsList = new LinkedList<>(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('Cyan'); colorsList.add('Magenta'); //convert List to stream & print it System.out.println('The contents of LinkedList:'); colorsList.stream().forEach(System.out::println); } } Produktion: 
 Innehållet i LinkedList: 
Netto 
Grön 
Blå 
Cyan 
Magenta
  
 Vanliga frågor
  F # 1) När används den länkade listan i Java? 
  Svar: Eftersom det är snabbare än samlingar som ArrayList i modifieringsåtgärder, bör det användas i applikationer som kräver frekvent tillägg / radering. För applikationer som oftast har skrivskyddad data kan ArrayList eller liknande samlingar användas.
  F # 2)  Vad är ListNode? 
  Svar: En ListNode är en basklass som är associerad med en länkad lista i Java och representerar information som är associerad med ett enda element eller en nod. Varje ListNode består av data och en pekare eller hänvisning till nästa element.
  F # 3)  Tillåter den länkade listan nollvärden? 
  Svar: Ja, den länkade listan tillåter valfritt antal nollvärden.
c ++ karaktär till sträng
  F # 4)  Vilka är fördelarna med en länkad lista? 
  Svar: Några av fördelarna är: 
  Manipulationsåtgärder som tillägg, radering är snabbare i det.
 Det finns inget behov av att fördela minne för en länkad lista och det resulterar således i effektivt minnesutnyttjande.
 Det ger snabbare åtkomsttid och utan extra omkostnader för minne och kan utökas på konstant tid.
 Det är en dynamisk datastruktur
 Växer och krymper vid körning beroende på värden som läggs till eller tas bort.
 
  F # 5)  Vad är tillämpningen av den länkade listan? 
  Svar: Det används främst i följande applikationer: 
  Att implementera 'ångra' -funktionalitet i programvara som MS-Word, Photoshop, etc.
 Att implementera datastrukturer som stack och kö.
 Vi kan också implementera diagram med hjälp av en länkad lista.
 För skopa-hashing kan varje skopa implementeras som en länkad lista.
 
  F # 6)  Vilka är begränsningarna för en länkad lista? 
  Svar: Några av begränsningarna är: 
  Med en ytterligare pekare för att hålla referensen för nästa element i varje nod är minnet som används mycket mer än matriser.
 Detta är en strikt sekventiell åtkomst till datastruktur, därför måste noder i den länkade listan alltid läsas från början.
 Det är svårt att korsa det bakåt, särskilt de enstaka länkarna.
 Eftersom noderna lagras på icke-sammanhängande platser kan tiden som krävs för åtkomst vara hög.
 
 Slutsats
 I denna handledning har vi lärt oss den grundläggande länkade datastrukturen. Sedan fortsatte vi klassen java.util.LinkedList som tillhandahålls i Java. Vi diskuterade denna klass i detalj inklusive dess konstruktörer, metoder etc.
 Vi har också diskuterat några speciella operationer relaterade till länkade listor som att sortera, vända en lista, ta bort dubbletter, cirkulär länkad lista etc.
   I vår nästa handledning kommer vi att diskutera specifika funktioner i den dubbelt länkade listan.  
  => Kolla in den kompletta Java-träningsguiden här.  
  Rekommenderad läsning
    Dubbel länkad lista i Java - Implementering och kodexempel  
  Java List - Hur man skapar, initialiserar och använder lista i Java  
  Java List Methods - Sortera lista, innehåller, Lägg till lista, ta bort lista  
  Binär sökalgoritm i Java - Implementering och exempel  
  Insertion Sort In Java - Insertion Sort Algorithm & Exempel  
  Java-gränssnitt och abstrakt klasshandledning med exempel  
  Länkad listdatastruktur i C ++ med illustration  
  Covert List to Array and Other Collections In Java