Verknüpfte Liste in Java - Beispiele für die Implementierung verknüpfter Listen und Java

linked list java linked list implementation java examples

Versuchen Sie Unser Instrument, Um Probleme Zu Beseitigen

Wählen Sie Das Betriebssystem Aus Wählen Sie Ein Projektionsprogramm (Optional)

Beschreiben Sie Ihr Problem

In diesem Lernprogramm wird erläutert, was eine Datenstruktur für verknüpfte Listen in Java ist und wie eine verknüpfte Java-Liste erstellt, initialisiert, implementiert, durchlaufen, umgekehrt und sortiert wird:

In Java ist eine LinkedList eine Datenstruktur, in der Elemente an einem nicht zusammenhängenden Speicherort gespeichert werden. Es ist eine lineare Datenstruktur.

Jedes Datenelement wird als 'Knoten' bezeichnet und jeder Knoten hat einen Datenteil und einen Adressenteil. Der Adressteil speichert den Link zum nächsten Knoten in der LinkedList.

=> Besuchen Sie hier, um die Java-Schulungsreihe für alle zu sehen.

Verknüpfte Liste in Java

Was du lernen wirst:

LinkedList In Java
Fazit
- Literatur-Empfehlungen

LinkedList In Java

Im Folgenden finden Sie das allgemeine Layout von LinkedList:

allgemeines Layout von LinkedList

Wie in der obigen Darstellung von LinkedList gezeigt, ist jedes Element in der LinkedList der „Knoten“. Jeder Knoten besteht aus zwei Teilen, der erste Teil speichert die Daten und der zweite Teil enthält eine Referenz oder einen Zeiger oder eine Adresse des nächsten Knotens in der LinkedList.

linker Join versus linker äußerer Join

Diese Anordnung ist erforderlich, da die Daten in LinkedList im Gegensatz zu Arrays an nicht zusammenhängenden Orten gespeichert werden.

Der „Kopf“ der LinkedList ist ein Zeiger, der die Adresse des ersten Elements in der LinkedList enthält. Der letzte Knoten in der LinkedList ist das Ende. Wie in der obigen Abbildung gezeigt, wird der Adressteil des letzten Knotens in der LinkedList auf 'Null' gesetzt, um das Ende der LinkedList anzuzeigen.

Das obige Diagramm zeigt ein “ Einfach verknüpfte Liste ”, In dem nur die Adresse des nächsten Knotens in der LinkedList gespeichert wird.

Es gibt eine andere Version, die als „ Doppelt verknüpfte Liste ”Dessen jeder Knoten drei Teile hat:

Adresse oder Referenz oder Zeiger auf das vorherige Element in der LinkedList.
Datenteil
Adresse oder Referenz oder Zeiger auf das nächste Element in der LinkedList.

Die vorherige Adresse des ersten Elements in der LinkedList wird auf Null gesetzt, während der nächste Zeiger des letzten Elements in der LinkedList auf Null gesetzt wird.

Darstellung der doppelt verknüpften Liste:

doppelt verknüpfte Liste

Wie in der obigen Darstellung gezeigt, hat jeder Knoten in der doppelt verknüpften Liste Zeiger auf seinen vorherigen und nächsten Knoten (also ohne Pfeile dargestellt). Der vorherige Zeiger des ersten Knotens zeigt auf Null, während der nächste Zeiger des letzten Knotens auf Null zeigt.

In diesem Tutorial zu LinkedList werden wir uns hauptsächlich mit der einfach verknüpften Liste befassen. Wir werden die doppelt verknüpfte Liste in unserem nächsten Tutorial diskutieren.

Java LinkedList-Klasse

In Java wird die verknüpfte Liste durch die LinkedList Klasse. Diese Klasse gehört zu den “ java.util ”Paket. Die LinkedList-Klasse implementiert die List- und Deque-Schnittstellen und erbt die AbstractList-Klasse.

Im Folgenden ist die Klassenhierarchie der LinkedList-Klasse angegeben.

Klassenhierarchie der LinkedList-Klasse

Das obige Diagramm zeigt die Hierarchie der LinkedList-Klasse. Wie gezeigt, implementiert die LinkedList-Klasse die List- und Deque-Schnittstellen.

Wie bereits erwähnt, ist die LinkedList-Klasse Teil der „ java.util ”Paket. Daher sollten Sie in der Lage sein, die LinkedList-Klasse in Ihrem Programm zu verwenden, indem Sie eine der folgenden Anweisungen in Ihr Programm aufnehmen.

import java.util.*;

Oder

import java.util.LinkedList;

Basierend auf der obigen Hierarchie lautet eine typische Definition der LinkedList-Klasse wie folgt:

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

Nachfolgend sind einige der Merkmale der LinkedList-Klasse aufgeführt, an die Sie sich erinnern sollten:

Diese Klasse ist nicht synchronisiert.
Es erlaubt doppelte Werte.
Behält die Einfügereihenfolge bei.
Da Elemente während der Bewegung nicht verschoben werden müssen, ist die Manipulation der darin enthaltenen Elemente schneller.
Diese Klasse kann verwendet werden, um einen Stapel, eine Warteschlange und eine Liste zu implementieren.

So erstellen Sie eine verknüpfte Liste in Java

Bevor wir mit dem Erstellen einer verknüpften Liste in Java fortfahren, wollen wir zunächst einen verknüpften Listenknoten in Java erläutern.

Wie bereits erwähnt, besteht eine verknüpfte Liste aus Knoten. Daher können wir in Java eine LinkedList als Klasse mit ihrem Knoten als separate Klasse darstellen. Daher wird diese Klasse einen Verweis auf den Knotentyp haben.

Dies wird wie folgt gezeigt:

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

Um ein Objekt vom Typ LinkedList zu erstellen, gibt es zwei Hauptkonstruktoren:

# 1) LinkedList ()

Die allgemeine Syntax für diesen Konstruktor lautet:

LinkedList linkedList = new LinkedList();

Die obige Anweisung erstellt eine leere LinkedList.

Zum Beispiel,

LinkedList l_list = new LinkedList();

Dadurch wird eine leere verknüpfte Liste mit dem Namen l_list erstellt.

# 2) LinkedList (Sammlung c)

Die allgemeine Syntax lautet:

LinkedList linkedList = new LinkedList (Collection c);

Die obige Anweisung erstellt eine LinkedList mit Elementen aus der Auflistung c als Anfangselementen.

Wie andere Listendatenstrukturen, die wir bereits gesehen haben, kann die verknüpfte Liste auch mit der Methode add, der Methode Arrays.asList () oder mithilfe des Konstruktors mit der Auflistung als Argument initialisiert werden.

Implementierung einer verknüpften Liste in Java

Im Folgenden finden Sie ein einfaches Beispiel für eine LinkedList-Datenstruktur in Java. In diesem Implementierungsbeispiel verwenden wir die add-Methode und die asList-Methode, um die LinkedList-Objekte zu initialisieren.

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

Ausgabe:

Inhalt der ersten LinkedList: (10, 20, 30, 40, 50)
Inhalt der zweiten LinkedList: (Rot, Grün, Blau, Cyan, Magenta)

Implementierung einer ausgabegebundenen Liste

Das obige Programm zeigt die Erstellung und Initialisierung der LinkedList. Zuerst erstellen wir eine LinkedList vom Typ Integer und stellen ein Array von Integers bereit, die mithilfe der asList-Methode als Anfangswerte für die LinkedList in eine Liste konvertiert wurden.

Als Nächstes erstellen wir eine leere LinkedList vom Typ String und fügen dann mithilfe der add-Methode Werte zur LinkedList hinzu.

Schließlich zeigen wir beide LinkedList-Objekte als Zeichenfolge an.

Verknüpfte Liste in Java durchlaufen / drucken

Um den Inhalt zu drucken oder Operationen an den Elementen der LinkedList auszuführen, müssen Sie deren Elemente durchlaufen. Wir haben diese Methoden bereits in unseren vorherigen Tutorials gesehen. In diesem Abschnitt werden die einzelnen Beispiele in Bezug auf LinkedList erläutert.

Verwenden der for-Schleife

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  Ausgabe: 
 LinkedList-Elemente mit for-Schleife: 
rot grün blau
  
 ForEach-Schleife verwenden
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 + ' '); } } }  Ausgabe: 
 LinkedList-Elemente mit forEach-Schleife: 
rot grün blau
  
 Iterator verwenden
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() + ' '); } } }  Ausgabe: 
 Der Inhalt der verknüpften Liste: 
Rot Grün Blau Gelb
Welche Software-Test-Zertifizierung ist die beste?
  
 LinkedList-Methoden
 Die LinkedList-Klasse bietet eine API, die verschiedene Methoden zum Bearbeiten der verknüpften Liste unterstützt. Wir haben die Methoden in der LinkedList-API unten tabellarisch aufgeführt.
  Wir werden die wichtigsten Operationen / Methoden im folgenden Abschnitt diskutieren. 
   Methode Prototyp Beschreibung  
 
  klar void clear () Löscht alle Elemente aus der Liste.  
 Hinzufügen Boolesches Addieren (E e) Fügen Sie der LinkedList ein angegebenes Element hinzu  
  void add (int index, E element) Fügen Sie am angegebenen Index in LinkedList ein Element hinzu  
  Füge alle Hinzu boolean addAll (Sammlung c) Fügt die Elemente der angegebenen Sammlung c am Ende der LinkedList hinzu.  
  boolean addAll (int index, Sammlung c) Fügt die Elemente der angegebenen Sammlung c am angegebenen Index in der LinkedList hinzu  
  addFirst void addFirst (E e) Fügen Sie das angegebene Element als erstes Element zur LinkedList hinzu.  
  addLast void addLast (E e) Fügen Sie das angegebene Element am Ende der Liste hinzu.  
   Klon Objektklon () Erstellt eine flache Kopie von LinkedList  
  Enthält Boolescher Wert enthält (Objekt o) Überprüft, ob die Liste bestimmte Elemente enthält. Wenn ja, wird true zurückgegeben.  
  absteigender Iterator Iterator absteigendIterator () Gibt einen Iterator in umgekehrter Reihenfolge für die LinkedList zurück.  
  Element E Element () Gibt das Element am Anfang der Liste zurück.  
  Erhalten E get (int index) Ruft das Element am angegebenen Index ab.  
  getFirst E getFirst () Ruft das erste Element in der LinkedList ab.  
  getLast E getLast () Ruft das letzte Element in der LinkedList ab.  
  Index von Int indexOf (Objekt o) Suchen Sie den Index des ersten Auftretens der angegebenen Elemente in der Liste und geben Sie den Index zurück. -1 wenn Element nicht gefunden wird.  
  lastIndexOf Int lastIndexOf (Objekt o) Gibt die Position des letzten Auftretens des angegebenen Elements in der LinkedList zurück; -1, wenn das angegebene Element nicht vorhanden ist  
  listIterator ListIterator listIterator (int index) Gibt den listIterator aus dem angegebenen Index in der verknüpften Liste zurück.  
  Angebot Boolesches Angebot (E e) Fügt das angegebene Element als letztes Element (Ende) in der LinkedList hinzu.  
  Angebot zuerst Boolesches AngebotFirst (E e) Fügt das angegebene Element als erstes Element in die LinkedList ein.  
  AngebotLetzte Boolesches AngebotLetzt (E e) Fügen Sie das angegebene Element e am Ende der LinkedList hinzu.  
  Spähen E peek () Gibt den Kopf der Liste zurück, ohne ihn zu entfernen.  
  peekFirst E peekFirst () Gibt das erste Element in der Liste zurück. Gibt null zurück, wenn die Liste leer ist.  
  peekLast E peekLast () Gibt das letzte Element oder null zurück, wenn die Liste leer ist. Das Element wird nicht gelöscht.  
  Umfrage E Umfrage () Gibt den Kopf der LinkedList zurück und entfernt ihn ebenfalls.  
  pollFirst E pollFirst () Gibt das erste Element in der Liste zurück und löscht es. Gibt null zurück, wenn die Liste leer ist.  
  pollLast E pollLast () Gibt das letzte Element in der Liste zurück und löscht es. Gibt null zurück, wenn die Liste leer ist.  
  Pop E pop () Entfernt das Element aus der Stapeldarstellung von LinkedList.  
  drücken Leerenschub (E e) Schiebt ein Element in die Stapeldarstellung der LinkedList oder fügt es ein.  
  Entfernen E entferne () Entfernt den Kopf der LinkedList und gibt ihn zurück.  
  E entfernen (int index) Löscht das Element am angegebenen Index aus der LinkedList.  
  boolean remove (Objekt o) Löscht das erste Vorkommen des angegebenen Elements aus der LinkedList.  
  removeFirst E removeFirst () Gibt das erste Element zurück und löscht es aus der Liste.  
  removeFirstOccurence boolean removeFirstOccurrence (Objekt o) Löscht das erste Vorkommen des angegebenen Elements aus der Liste, wenn die Liste von Kopf bis Ende durchlaufen wird.  
  removeLast E removeLast () Gibt das letzte Element in der LinkedList zurück und löscht es auch.  
  removeLastOccurence boolean removeLastOccurrence (Objekt o) Entfernt das letzte Vorkommen des angegebenen Elements aus der LinkedList, wenn es von Kopf bis Schwanz durchlaufen wird  
  einstellen E set (int index, E element) Legt das angegebene Element auf den angegebenen Index fest. Ersetzt das aktuelle Element durch ein neues.  
  Größe Int size () Gibt die Größe oder Anzahl der Elemente in der LinkedList zurück  
  toArray Objekt () toArray () Konvertiert die LinkedList in ein Array, das alle Listenelemente in der richtigen Reihenfolge enthält  
  T () toArray (T () a) Konvertiert LinkedList in ein Array mit dem gleichen Laufzeittyp wie Argument a.  
 
 
  Das folgende Java-Programm demonstriert die verschiedenen oben aufgeführten Methoden. 
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)); } } Ausgabe: 
 Verknüpfte Liste: (A, B, C, D, G, E, F) 
Verknüpfte Liste nach dem Hinzufügen von ArrayList-Inhalten: (A, B, C, D, G, E, F, H, I) 
Verknüpfte Liste nach Löschung: (C, D, E, F, H) 
Die Liste enthält nicht das Element 'G'. 
Größe der verknüpften Liste = 5 
Von get () zurückgegebenes Element: F. 
Verknüpfte Liste nach Änderung: (C, D, E, J, H) 
Array aus verknüpfter Liste erhalten: (C, D, E, J, H)
  
 Das obige Programm demonstriert verschiedene Methoden der LinkedList-Klasse. Zuerst deklarieren wir eine LinkedList vom Typ String. Dann verwenden wir verschiedene Versionen der add-Methode wie add, andFirst, addLast, addAll usw., um die LinkedList mit Werten zu füllen.
 Hier können wir das Element direkt am Ende der Liste hinzufügen oder das Element an einer bestimmten Position in der Liste hinzufügen.
 Wir verwenden auch die addFirst-Methode, um ein Element am Anfang der Liste hinzuzufügen, und addLast, um ein Element am Ende der Liste hinzuzufügen. Dann führen wir Entfernungsvorgänge für die LinkedList aus, z. B. remove, removeFirst, removeLast usw.
 Für die Methode remove können wir entweder das zu entfernende Element oder den Index oder die Position in der LinkedList angeben, an der das Element entfernt werden soll. Die Methoden removeFirst und removeLast entfernen das erste und das letzte Element in der Liste.
 Dann durchsuchen wir die Liste nach einem bestimmten Element mit der Methode includes. Als Nächstes verwenden wir die size () -Methode, um die Größe oder Länge der LinkedList abzurufen. Dann verwenden wir get / set-Methoden, um den Wert an einem bestimmten Index in der Liste abzurufen und dann einen Wert an einer bestimmten Position in der Liste zu ersetzen.
  Schließlich konvertieren wir die LinkedList mit der toArray-Methode in ein Array. 
 Reverse Linked List In Java
 Um eine verknüpfte Liste in Java umzukehren, verwenden wir die Methode 'descendingIterator ()', die einen umgekehrten Iterator für die Liste zurückgibt. Mit diesem Iterator können wir dann die Listen- und Anzeigeelemente durchlaufen.
  Das folgende Programm kehrt die verknüpfte Liste mit der Methode descendingIterator () um. 
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() + ' '); } } }  Ausgabe: 
 Verknüpfte Liste: (Pune, Mumbai, Nagpur) 
Verknüpfte Liste in umgekehrter Reihenfolge: 
Nagpur Mumbai Pune
  
 Im obigen Programm deklarieren wir eine verknüpfte Liste und drucken sie dann aus. Dann erhalten wir einen umgekehrten Iterator und gehen damit die Liste durch und zeigen jedes Element an. Die Ausgabe zeigt den Inhalt der verknüpften Liste, zuerst in der Reihenfolge, in der die Elemente hinzugefügt werden, und dann zeigt die Ausgabe den Inhalt in umgekehrter Reihenfolge.
 Sortieren Sie eine verknüpfte Liste in Java
 LinkedList-Klassenobjekte können mit der Collections.sort () -Methode sortiert werden. Diese Methode bietet zwei Versionen mit oder ohne Verwendung eines Komparators. Wenn die Collections.sort () -Methode ohne Komparator aufgerufen wird, wird die Sammlung in der natürlichen Reihenfolge sortiert.
 Wenn die Komparator Wenn diese Methode verwendet wird, können wir unsere eigenen Sortierkriterien definieren, indem wir die compareTo-Methode überschreiben.
  Das folgende Java-Programm sortiert eine LinkedList mit Collections.sort (). Hier sortieren wir Arrays nach natürlicher Reihenfolge sowie nach einem 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); } } Ausgabe: 
 Original LinkedList (unsortiert): (Jan, Feb, Mar, Apr, Mai, Jun) 
LinkedList (in natürlicher Reihenfolge sortiert): (Apr, Feb, Jan, Jun, Mar, Mai) 
LinkedList (sortiert mit Comparator): (Apr, Feb, Jan, Jun, Mar, Mai)
  
 Duplikate entfernen
 Um Duplikate zu entfernen, müssen Sie jeden Knoten durchlaufen und mit dem nächsten Knoten vergleichen. Wenn beide Knoten gleich sind, überspringen wir einen Knoten und wechseln zum nächsten.
 Auf diese Weise erhalten wir nach dem Durchlaufen jedes einzelnen Knotens und dem Entfernen doppelter Knoten die resultierende Liste, die keine doppelten Elemente enthält.
  Im Folgenden finden Sie ein Java-Programm zum Entfernen von Duplikaten. 
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(); } }  Ausgabe: 
 Ursprüngliche verknüpfte Liste: 
1 1 2 3 5 2 1 1 
LinkedList nach dem Entfernen von Duplikaten: 
1 2 3 5
  
 Im obigen Programm haben wir eine verknüpfte Listenklasse erstellt, um Duplikate zu entfernen. Wir haben auch eine Klasse, um jeden Knoten zu definieren. Mit anderen Worten, die Knoten in der Liste sind die Objekte dieses Klassenknotens. Wir haben eine Methode, um den Knoten einer verknüpften Liste hinzuzufügen.
 Dann durchlaufen wir in der removeDuplicate-Methode jeden Knoten in der verknüpften Liste ausgehend vom Kopf und vergleichen jeden nachfolgenden Knoten auf das Duplikat. Wenn ein Duplikat gefunden wird, überspringen wir diesen Knoten und fahren mit dem nächsten Knoten fort.
 Auf diese Weise wird das Ist durch Überspringen der doppelten Knoten erstellt und die geänderte Liste wird mit der print () -Methode gedruckt.
 Zirkuläre verknüpfte Liste in Java
 Eine zirkuläre verknüpfte Liste ist eine Liste, deren Ende oder letzter Knoten wieder mit dem Kopf oder dem ersten Knoten verbunden ist.
  Das folgende Diagramm zeigt die Circular Linked List in Java. 
  
beste kostenlose Video-Downloader Windows 10
 Wie im obigen Diagramm gezeigt, wird der Adressteil des letzten Knotens oder Endes der verknüpften Liste nicht auf Null gesetzt. Stattdessen zeigt es zurück auf den ersten Knoten oder Kopf der Liste und bildet so eine kreisförmig verknüpfte Liste.
  Das folgende Programm implementiert eine zirkuläre verknüpfte Liste, in der einzelne Knoten der verknüpften Liste bearbeitet werden müssen. 
 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(); } }  Ausgabe: 
 Zirkuläre verknüpfte Listenknoten: 
10 20 30 40
  
 Java 8 LinkedList
 Obwohl in Linked 8 keine weiteren Funktionen speziell zur LinkedList-Klasse hinzugefügt wurden, wurden Streams zum Bearbeiten von Daten eingeführt.
  Das folgende Programm zeigt die Verwendung des Java 8-Streams zum Anzeigen von 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); } } Ausgabe: 
 Der Inhalt von LinkedList: 
Netz 
Grün 
Blau 
Cyan 
Magenta
  
 Häufig gestellte Fragen
  F # 1) Wann wird die verknüpfte Liste in Java verwendet? 
  Antworten: Da es bei Änderungsvorgängen schneller als Sammlungen wie ArrayList ist, sollte es in Anwendungen verwendet werden, die häufige Hinzufügungs- / Löschvorgänge erfordern. Für Anwendungen mit meist schreibgeschützten Daten können ArrayList oder ähnliche Sammlungen verwendet werden.
  Q # 2)  Was ist ListNode? 
  Antworten: Ein ListNode ist eine Basisklasse, die einer verknüpften Liste in Java zugeordnet ist und Informationen darstellt, die einem einzelnen Element oder einem Knoten zugeordnet sind. Jeder ListNode besteht aus Daten und einem Zeiger oder Verweis auf das nächste Element.
  Q # 3)  Erlaubt die verknüpfte Liste Nullwerte? 
  Antworten: Ja, die verknüpfte Liste erlaubt eine beliebige Anzahl von Nullwerten.
  Q # 4)  Was sind die Vorteile einer verknüpften Liste? 
  Antwort: Einige der Vorteile sind: 
  Manipulationsvorgänge wie Hinzufügen und Löschen sind schneller.
 Es ist nicht erforderlich, Speicher für eine verknüpfte Liste vorab zuzuweisen, was zu einer effizienten Speichernutzung führt.
 Es bietet eine schnellere Zugriffszeit und ohne zusätzlichen Speicheraufwand und kann in konstanter Zeit erweitert werden.
 Es ist eine dynamische Datenstruktur
 Wächst und schrumpft zur Laufzeit je nach hinzugefügten oder gelöschten Werten.
 
  Q # 5)  Was ist die Anwendung der verknüpften Liste? 
  Antwort: Es wird hauptsächlich in folgenden Anwendungen verwendet: 
  Implementieren der Funktion zum Rückgängigmachen in Software wie MS-Word, Photoshop usw.
 Implementieren von Datenstrukturen wie Stapel und Warteschlange.
 Wir können Diagramme auch mithilfe einer verknüpften Liste implementieren.
 Für das Bucket-Hashing kann jeder Bucket als verknüpfte Liste implementiert werden.
 
  Q # 6)  Was sind die Einschränkungen einer verknüpften Liste? 
  Antwort: Einige der Einschränkungen sind: 
  Mit einem zusätzlichen Zeiger, der die Referenz des nächsten Elements in jedem Knoten enthält, ist der verwendete Speicher viel mehr als Arrays.
 Dies ist eine Datenstruktur, auf die ausschließlich nacheinander zugegriffen wird. Daher müssen Knoten der verknüpften Liste immer von Anfang an gelesen werden.
 Es ist schwierig, es rückwärts zu durchlaufen, insbesondere die einfach verknüpften Listen.
 Da die Knoten an nicht zusammenhängenden Orten gespeichert sind, kann die für den Zugriff erforderliche Zeit hoch sein.
 
 Fazit
 In diesem Tutorial haben wir die grundlegende Datenstruktur für verknüpfte Listen kennengelernt. Dann sind wir zu der in Java bereitgestellten Klasse java.util.LinkedList übergegangen. Wir haben diese Klasse einschließlich ihrer Konstruktoren, Methoden usw. ausführlich besprochen.
 Wir haben auch einige spezielle Vorgänge im Zusammenhang mit verknüpften Listen besprochen, z. B. Sortieren, Umkehren einer Liste, Entfernen von Duplikaten, zirkuläre verknüpfte Listen usw.
   In unserem nächsten Tutorial werden wir die spezifischen Funktionen der doppelt verknüpften Liste diskutieren.  
  => Lesen Sie hier den vollständigen Java-Schulungsleitfaden.  
  Literatur-Empfehlungen
    Doppelt verknüpfte Liste in Java - Implementierungs- und Codebeispiele  
  Java-Liste - Erstellen, Initialisieren und Verwenden einer Liste in Java  
  Java-Listenmethoden - Liste sortieren, Enthält, Liste hinzufügen, Liste entfernen  
  Binärer Suchalgorithmus in Java - Implementierung und Beispiele  
  Einfügungssortierung in Java - Einfügungssortierungsalgorithmus und Beispiele  
  Java Interface und Abstract Class Tutorial mit Beispielen  
  Datenstruktur der verknüpften Liste in C ++ mit Abbildung  
  Verdeckte Liste in Array und andere Sammlungen in Java