Prepojený zoznam v Jave - Implementácia prepojeného zoznamu a príklady Java

linked list java linked list implementation java examples

V tomto výučbe sa dozviete, čo je dátová štruktúra prepojeného zoznamu v jazyku Java a ako vytvárať, inicializovať, implementovať, prechádzať, obracať a triediť zoznam prepojených Java:

V Jave je LinkedList dátová štruktúra, ktorá ukladá prvky na nesúvislom mieste. Je to lineárna dátová štruktúra.

Každá údajová položka sa nazýva „Uzol“ a každý uzol má dátovú časť a časť adresy. V časti s adresou sa ukladá odkaz na nasledujúci uzol v zozname LinkedList.

=> Navštívte tu a pozrite si sériu školení Java pre všetkých.

Prepojený zoznam v Jave

Čo sa dozviete:

LinkedList v Jave
Záver
- Odporúčané čítanie

LinkedList v Jave

Ďalej je uvedené všeobecné rozloženie LinkedList:

všeobecné rozloženie LinkedList

Ako je znázornené na vyššie uvedenom obrázku LinkedList, každá položka v zozname LinkedList je „Uzol“. Každý uzol má dve časti, prvá časť ukladá údaje a druhá časť má odkaz alebo ukazovateľ alebo adresu nasledujúceho uzla v zozname LinkedList.

Toto usporiadanie je nevyhnutné, pretože údaje v zozname LinkedList sa na rozdiel od polí ukladajú na nespojitých miestach.

oracle pl sql rozhovor otázky a odpovede na skúsený pdf

„Hlava“ LinkedList je ukazovateľ, ktorý obsahuje adresu prvého prvku v LinkedList. Posledný uzol v zozname LinkedList je chvost. Ako je znázornené na obrázku vyššie, adresná časť posledného uzla v zozname LinkedList je nastavená na hodnotu „Null“, ktorá označuje koniec zoznamu LinkedList.

Vyššie uvedený diagram predstavuje „ Zoznam spojený s jedným odkazom ”, Ktorý ukladá adresu iba nasledujúceho uzla v zozname LinkedList.

Existuje ďalšia verzia známa ako „ Dvojnásobne prepojený zoznam ”Ktorého každý uzol má tri časti:

Adresa alebo odkaz alebo odkaz na predchádzajúci prvok v zozname LinkedList.
Dátová časť
Adresa alebo odkaz alebo odkaz na nasledujúci prvok v zozname LinkedList.

Predchádzajúca adresa prvého prvku v zozname LinkedList bude nastavená na hodnotu Null, zatiaľ čo ďalší ukazovateľ posledného prvku v zozname LinkedList je nastavený na hodnotu Null.

Zastúpenie nepochybne prepojeného zoznamu:

dvojnásobne prepojený zoznam

Ako je znázornené na vyššie uvedenom obrázku, každý uzol v zozname, ktorý je dvojnásobne prepojený, má ukazovatele na svoj predchádzajúci a nasledujúci uzol (teda zobrazené bez šípok). Predchádzajúci ukazovateľ prvého uzla ukazuje na hodnotu null, zatiaľ čo ďalší ukazovateľ posledného uzla ukazuje na hodnotu null.

V tomto tutoriáli LinkedList sa budeme zaoberať väčšinou jednotlivo prepojeným zoznamom. O dvojnásobne prepojenom zozname sa budeme rozprávať v našom ďalšom návode.

Trieda Java LinkedList

V Jave je prepojený zoznam implementovaný pomocou „ LinkedList ' trieda. Táto trieda patrí do triedy „ java.util ”Balíček. Trieda LinkedList implementuje rozhrania List a Deque a dedí triedu AbstractList.

Ďalej je uvedená hierarchia tried triedy LinkedList.

hierarchia tried triedy LinkedList

Vyššie uvedený diagram zobrazuje hierarchiu triedy LinkedList. Ako je znázornené, trieda LinkedList implementuje rozhrania List a Deque.

Ako už bolo spomenuté, trieda LinkedList je súčasťou „ java.util ”Balíček. Preto by ste mali byť schopní používať triedu LinkedList vo vašom programe zahrnutím jedného z nasledujúcich príkazov do vášho programu.

import java.util.*;

Alebo

import java.util.LinkedList;

Na základe vyššie uvedenej hierarchie je teda typická definícia triedy LinkedList nasledovná:

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

Nižšie sú uvedené niektoré charakteristiky triedy LinkedList, ktoré by ste si mali pamätať:

Táto trieda nie je synchronizovaná.
Umožňuje duplicitné hodnoty.
Ponechá si objednávku vloženia.
Pretože sa nevyžaduje, aby sa prvky posúvali pri pohybe, manipulácia s prvkami v ňom je rýchlejšia.
Túto triedu možno použiť na implementáciu zásobníka, frontu a zoznamu.

Ako vytvoriť prepojený zoznam v Jave

Predtým, ako prejdeme k vytvoreniu prepojeného zoznamu v prostredí Java, najskôr si predstavme uzol prepojeného zoznamu v prostredí Java.

Ako už bolo uvedené, prepojený zoznam sa skladá z uzlov. V Jave teda môžeme reprezentovať LinkedList ako triedu s jej Uzlom ako samostatnú triedu. Preto bude mať táto trieda odkaz na typ Uzol.

Toto je zobrazené nižšie:

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

Na vytvorenie objektu typu LinkedList existujú dva hlavné konštruktory:

# 1) LinkedList ()

Všeobecná syntax pre tento konštruktor je:

LinkedList linkedList = new LinkedList();

Vyššie uvedené vyhlásenie vytvorí prázdny LinkedList.

Napríklad,

LinkedList l_list = new LinkedList();

Týmto sa vytvorí prázdny prepojený zoznam s názvom l_list.

# 2) LinkedList (zbierka c)

Všeobecná syntax je:

LinkedList linkedList = new LinkedList (Collection c);

Vyššie uvedené vyhlásenie vytvorí LinkedList s prvkami z kolekcie c ako počiatočnými prvkami.

Rovnako ako ďalšie dátové štruktúry zoznamu, ktoré sme už videli, je možné prepojený zoznam tiež inicializovať pomocou metódy add, metódy Arrays.asList () alebo pomocou konštruktora so zbierkou ako argument.

Implementácia prepojeného zoznamu v Jave

Ďalej je uvedený jednoduchý príklad dátovej štruktúry LinkedList v Jave. V tomto príklade implementácie použijeme na inicializáciu objektov LinkedList metódy add a asList.

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

Výkon:

Obsah prvého LinkedList: [10, 20, 30, 40, 50]
Obsah druhého LinkedList: [červená, zelená, modrá, azúrová, purpurová]

implementácia zoznamu prepojeného s výstupom

Vyššie uvedený program ukazuje vytvorenie a inicializáciu LinkedList. Najskôr vytvoríme LinkedList typu Integer a poskytneme pole celých čísel prevedených do zoznamu pomocou metódy asList ako počiatočné hodnoty pre LinkedList.

Ďalej vytvoríme prázdny LinkedList typu String a potom pomocou metódy add pridáme hodnoty do LinkedList.

Na záver zobrazíme oba objekty LinkedList ako reťazec.

Prechádzať / tlačiť prepojený zoznam v prostredí Java

Ak chcete vytlačiť obsah alebo vykonať akékoľvek operácie s prvkami LinkedList, musíte prechádzať jeho prvkami. Tieto metódy sme už videli v našich predchádzajúcich tutoriáloch. V tejto časti rozoberieme príklady každého z nich vo vzťahu k LinkedList.

Pomocou slučky for

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  Výkon: 
 Prvky LinkedList pomocou slučky for: 
Červená Zelená Modrá
  
 Pomocou 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 + ' '); } } }  Výkon: 
 Prvky LinkedList pomocou slučky forEach: 
Červená Zelená Modrá
  
 Pomocou Iterátora
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() + ' '); } } }  Výkon: 
 Obsah prepojeného zoznamu: 
Červená Zelená Modrá Žltá
  
c ++ typy dedenia
 Metódy LinkedList
 Trieda LinkedList poskytuje API, ktoré podporuje rôzne metódy manipulácie so zoznamom Linked. Metódy sú uvedené nižšie v zozname LinkedList API.
  V nasledujúcej časti si rozoberieme hlavné operácie / metódy. 
   Metóda Prototyp Popis  
 
  jasný prázdne miesto jasné () Vymaže všetky prvky zo zoznamu.  
 Pridať boolovský prírastok (E e) Pridajte zadaný prvok do zoznamu LinkedList  
  void add (int index, E element) Pridajte prvok v danom indexe do LinkedList  
  Pridať všetko boolean addAll (kolekcia c) Pridá prvky danej kolekcie c na koniec LinkedList.  
  boolean addAll (int index, kolekcia c) Pridá prvky danej kolekcie c do zadaného indexu v zozname LinkedList  
  addFirst void addFirst (E e) Pridajte daný prvok ako prvý prvok do zoznamu LinkedList.  
  pridaťPosledné void addLast (E e) Pripojte daný prvok na koniec zoznamu.  
   Klonovať Klon objektu () Vytvorí plytkú kópiu súboru LinkedList  
  Obsahuje Boolean obsahuje (objekt o) Skontroluje, či zoznam obsahuje zadané prvky; ak áno, vráti sa pravda.  
  zostupneIterator Iterátor zostupneIterátor () Vráti obrátený iterátor pre LinkedList.  
  Prvok Prvok E () Vráti prvok na začiatku zoznamu.  
  Získajte Získať (int index) Získava prvok v zadanom indexe.  
  getFirst E getFirst () Načíta prvý prvok v zozname LinkedList.  
  getLast E getLast () Načíta posledný prvok v zozname LinkedList.  
  indexOf Int indexOf (objekt o) Vyhľadajte index prvého výskytu daných prvkov v zozname a index vráťte. -1, ak sa prvok nenašiel.  
  lastIndexOf Int lastIndexOf (objekt o) Vráti pozíciu posledného výskytu daného prvku v zozname LinkedList; -1, ak daný prvok nie je prítomný  
  listIterator ListIterator listIterator (int index) Vráti listIterator zo zadaného indexu v prepojenom zozname.  
  Ponuka boolovská ponuka (E e) Pridá daný prvok ako posledný prvok (koniec) do zoznamu LinkedList.  
  ponukaPrvé Booleovská ponukaPrvé (V e) Pridá daný prvok ako prvý prvok do LinkedList.  
  posledná ponuka Boolovská ponukaPosledné (V e) Pridajte daný prvok e na koniec LinkedList.  
  Nakuknúť E nahliadnuť () Vráti hlavičku zoznamu bez odstránenia.  
  nahliadnuťPrvé E peekFirst () Vráti prvý prvok v zozname. vráti nulu, ak je zoznam prázdny.  
  nakuknúťposledné E peekLast () Vráti posledný prvok alebo hodnotu null, ak je zoznam prázdny. Neodstráni sa prvok.  
  Anketa E anketa () Vráti hlavičku LinkedList a tiež ju odstráni.  
  anketaPrvý E pollFirst () Vráti a odstráni prvý prvok v zozname; vráti nulu, ak je zoznam prázdny.  
  anketaPosledné E anketaPosledná () Vráti a vymaže posledný prvok v zozname; vráti nulu, ak je zoznam prázdny.  
  Pop E pop () Vyskočí prvok z hromadnej reprezentácie LinkedList.  
  Tam Void push (E e) Vloží alebo vloží prvok do zásobníkovej reprezentácie LinkedList.  
  Odstrániť E odstrániť () Odstráni a vráti hlavičku LinkedList.  
  E remove (int index) Vymaže prvok v danom indexe z LinkedList.  
  boolean remove (Objekt o) Vymaže prvý výskyt daného prvku zo zoznamu LinkedList.  
  odobraťPrvé E removeFirst () Vráti a odstráni prvý prvok zo zoznamu.  
  removeFirstOccurence boolean removeFirstOccurrence (objekt o) Vymaže prvý výskyt daného prvku zo zoznamu, keď je zoznam prechádzaný od hlavy po chvost.  
  removePosledné E removeLast () Vráti posledný prvok v zozname LinkedList a tiež ho odstráni.  
  removeLastOccurence boolean removeLastOccurrence (objekt o) Odstráni posledný výskyt daného prvku zo zoznamu LinkedList pri prechode od hlavy po chvost  
  Nastaviť Sada E (int index, prvok E) Nastaví daný prvok na daný index. Nahradí aktuálny prvok novým.  
  Veľkosť Vnútorná veľkosť () Vráti veľkosť alebo počet prvkov v zozname LinkedList  
  toArray Objekt [] toArray () Skonvertuje LinkedList na pole obsahujúce všetky prvky zoznamu v správnom poradí  
  T [] toArray (T [] a) Konvertuje LinkedList na pole s typom runtime rovnakým ako argument a.  
 
 
  Nižšie uvedený program Java demonštruje rôzne metódy, ktoré sme uviedli vyššie. 
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)); } } Výkon: 
 Prepojený zoznam: [A, B, C, D, G, E, F] 
Prepojený zoznam po pridaní obsahu ArrayList: [A, B, C, D, G, E, F, H, I] 
Prepojený zoznam po odstránení: [C, D, E, F, H] 
Zoznam neobsahuje prvok „G“ 
Veľkosť prepojeného zoznamu = 5 
Prvok vrátený metódou get (): F 
Prepojený zoznam po zmene: [C, D, E, J, H] 
Pole získané z prepojeného zoznamu: [C, D, E, J, H]
  
 Vyššie uvedený program demonštruje rôzne metódy triedy LinkedList. Najskôr deklarujeme LinkedList typu String. Potom používame rôzne verzie metódy add, ako add, andFirst, addLast, addAll atď., Aby sme vyplnili zoznam LinkedList hodnotami.
 Tu môžeme pridať prvok priamo na koniec zoznamu alebo pridať prvok na určené miesto v zozname.
 Tiež používame metódu addFirst na pridanie prvku na začiatok zoznamu a addLast na pridanie prvku na koniec zoznamu. Potom vykonáme operácie odstránenia na zozname LinkedList, ako napríklad remove, removeFirst, removeLast atď.
 Pri metóde remove môžeme určiť prvok, ktorý sa má odstrániť, alebo môžeme určiť index alebo pozíciu v zozname LinkedList, na ktorej sa má prvok odstrániť. Metódy removeFirst a removeLast odstránia prvý a posledný prvok v zozname.
 Potom pomocou metódy contains vyhľadáme v zozname konkrétny prvok. Ďalej pomocou metódy size () získame veľkosť alebo dĺžku LinkedList. Potom pomocou metód get / set načítame hodnotu v konkrétnom indexe v zozname a potom nahradíme hodnotu na určenej pozícii v zozname.
  Nakoniec prevedieme LinkedList na Array pomocou metódy toArray. 
 Reverzne prepojený zoznam v Jave
 Na obrátenie prepojeného zoznamu v Jave používame metódu „descendingIterator ()“, ktorá vracia spätný iterátor zoznamu. Tento iterátor potom môžeme použiť na prechádzanie prvkami zoznamu a zobrazenia.
  Nasledujúci program obráti prepojený zoznam pomocou metódy 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() + ' '); } } }  Výkon: 
 Prepojený zoznam: [Pune, Mumbai, Nagpur] 
Prepojený zoznam v opačnom poradí: 
Nagpur Bombaj Pune
  
 Vo vyššie uvedenom programe deklarujeme prepojený zoznam a potom ho vytlačíme. Potom dostaneme spätný iterátor a potom pomocou neho prechádzame zoznamom a zobrazujeme každý prvok. Výstup zobrazuje prepojený obsah zoznamu, najskôr v poradí, v akom sú pridané prvky, a potom výstup zobrazuje obsah v opačnom poradí.
 Zoradiť prepojený zoznam v prostredí Java
 Objekty triedy LinkedList je možné triediť pomocou metódy Collections.sort (). Táto metóda poskytuje dve verzie s alebo bez použitia komparátora. Keď sa metóda Collections.sort () volá bez komparátora, kolekcia sa zoradí v prirodzenom poradí.
 Keď komparátor Keď sa použije táto metóda, môžeme definovať naše vlastné kritériá triedenia prepísaním metódy compareTo.
  Nižšie uvedený program Java triedi LinkedList podľa Collections.sort (). Tu triedime polia pomocou prirodzeného usporiadania aj pomocou komparátora. 
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); } } Výkon: 
 Originálny LinkedList (netriedený): [Jan, Feb, Mar, Apr, May, Jun] 
LinkedList (zoradené v prirodzenom poradí): [apríl, február, január, jún, marok, máj] 
LinkedList (zoradené podľa komparátora): [apr, feb, jan, jún, mar, máj]
  
 Odstrániť duplikáty
 Ak chcete odstrániť duplikáty, musíte prejsť každým uzlom a porovnať ho s ďalším uzlom. Ak sú oba uzly rovnaké, potom jeden uzol preskočíme a presunieme sa do ďalšieho.
 Týmto spôsobom, po prechode každého uzla a zbavení sa duplicitných uzlov, dostaneme výsledný zoznam, ktorý je bez akýchkoľvek duplicitných prvkov.
  Nižšie je uvedený program Java na odstránenie duplikátov. 
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(); } }  Výkon: 
 Pôvodný prepojený zoznam: 
1 1 2 3 5 2 1 1 
LinkedList po odstránení duplikátov: 
1 2 3 5
  
 Vo vyššie uvedenom programe máme vytvorenú triedu prepojeného zoznamu na odstránenie duplikátov. Máme tiež triedu na definovanie každého uzla. Inými slovami, uzly v zozname sú objektmi tohto uzla triedy. Máme spôsob, ako pridať uzol do prepojeného zoznamu.
 Potom v metóde removeDuplicate prechádzame každým uzlom v prepojenom zozname počínajúc od hlavy a porovnávame každý nasledujúci uzol s duplikátom. Ak sa nájde duplikát, daný uzol preskočíme a pokračujeme k ďalšiemu uzlu.
 Týmto spôsobom je ist zostavený preskočením duplicitných uzlov a zmenený zoznam je vytlačený pomocou metódy print ().
 Kruhový prepojený zoznam v Jave
 Kruhový prepojený zoznam je zoznam, ktorého chvost alebo posledný uzol je pripojený späť k hlavnému alebo prvému uzlu.
  Nasledujúci diagram zobrazuje zoznam kruhových odkazov v Jave. 
  
 Ako je znázornené na vyššie uvedenom diagrame, adresná časť posledného uzla alebo chvosta prepojeného zoznamu nie je nastavená na hodnotu null. Namiesto toho smeruje späť na prvý uzol alebo hlavičku zoznamu, čím sa vytvorí kruhový prepojený zoznam.
  Nasledujúci program implementuje kruhový prepojený zoznam, v ktorom musíme manipulovať s jednotlivými uzlami prepojeného zoznamu. 
 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(); } }  Výkon: 
 Uzly kruhového prepojeného zoznamu: 
10 20 30 40
  
 Prepojený zoznam Java 8
 Aj keď v triede Java 8 nie sú do triedy LinkedList špeciálne pridané žiadne ďalšie funkcie, stále predstavovala prúdy na manipuláciu s údajmi.
  Nasledujúci program ukazuje použitie toku Java 8 na zobrazenie 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); } } Výkon: 
 Obsah LinkedList: 
Netto 
zelená 
Modrá 
Tyrkysový 
Purpurová
  
 často kladené otázky
  Otázka 1) Kedy sa zoznam prepojených odkazov používa v prostredí Java? 
  Odpoveď: Pretože je v operáciách úprav rýchlejší ako kolekcie ako ArrayList, mal by sa používať v aplikáciách, ktoré vyžadujú časté operácie pridávania a odstraňovania. Pre aplikácie, ktoré majú väčšinou dáta iba na čítanie, je možné použiť ArrayList alebo podobné kolekcie.
  Otázka č. 2)  Čo je ListNode? 
  Odpoveď: ListNode je základná trieda spojená s prepojeným zoznamom v Jave a predstavuje informácie spojené s jedným prvkom alebo uzlom. Každý ListNode pozostáva z údajov a ukazovateľa alebo odkazu na nasledujúci prvok.
  Otázka č. 3)  Povolí prepojený zoznam nulové hodnoty? 
  Odpoveď: Áno, prepojený zoznam umožňuje ľubovoľný počet nulových hodnôt.
  Otázka č. 4)  Aké sú výhody prepojeného zoznamu? 
  Odpoveď: Niektoré z výhod sú: 
  Manipulačné operácie ako pridávanie a mazanie sú v ňom rýchlejšie.
 Nie je potrebné vopred vyhradiť pamäť pre prepojený zoznam, čo vedie k efektívnemu využitiu pamäte.
 Poskytuje rýchlejší prístupový čas a bez ďalších režijných nákladov na pamäť a je možné ho rozširovať v konštantnom čase.
 Je to dynamická dátová štruktúra
 Rastie a zmenšuje sa za behu v závislosti od pridaných alebo odstránených hodnôt.
 
  Otázka č. 5)  Aká je aplikácia prepojeného zoznamu? 
  Odpoveď: Používa sa väčšinou v nasledujúcich aplikáciách: 
  Implementácia funkcie „späť“ v softvéroch ako MS-Word, Photoshop atď.
 Implementovať dátové štruktúry ako zásobník a front.
 Grafy môžeme implementovať aj pomocou prepojeného zoznamu.
 Pri hašovaní segmentov je možné každý segment implementovať ako prepojený zoznam.
 
  Otázka č. 6)  Aké sú obmedzenia prepojeného zoznamu? 
otázky na javascriptový rozhovor pre skúsených odborníkov
  Odpoveď: Niektoré z obmedzení sú: 
  Vďaka ďalšiemu ukazovateľu na udržanie referencie nasledujúceho prvku v každom uzle je využitá pamäť oveľa viac ako polia.
 Toto je striktne sekvenčne prístupná dátová štruktúra, preto uzly prepojeného zoznamu musia byť vždy čítané od začiatku.
 Je ťažké prechádzať ho dozadu, najmä v jednotlivo prepojených zoznamoch.
 Pretože sú uzly uložené na nespojitých miestach, čas potrebný na prístup môže byť vysoký.
 
 Záver
 V tomto tutoriáli sme sa naučili základnú dátovú štruktúru prepojeného zoznamu. Potom sme prešli na triedu java.util.LinkedList poskytovanú v Jave. Podrobne sme diskutovali o tejto triede vrátane jej konštruktorov, metód atď.
 Diskutovali sme tiež o niektorých špeciálnych operáciách týkajúcich sa prepojených zoznamov, ako je triedenie, obrátenie zoznamu, odstránenie duplikátov, kruhový prepojený zoznam atď.
   V našom ďalšom tutoriáli sa budeme zaoberať konkrétnymi vlastnosťami dvojnásobne prepojeného zoznamu.  
  => Tu si pozrite kompletného sprievodcu Java Training.  
  Odporúčané čítanie
    Dvojnásobne prepojený zoznam v prostredí Java - implementácia a príklady kódov  
  Zoznam Java - Ako vytvoriť, inicializovať a používať zoznam v jazyku Java  
  Metódy zoznamu Java - triediť zoznam, obsahuje, pridať zoznam, zoznam odstrániť  
  Algoritmus binárneho vyhľadávania v prostredí Java - implementácia a príklady  
  Insertion Sort In Java - Algoritmus a príklady na triedenie vloženia  
  Výukový program pre rozhranie Java a abstraktnú triedu s príkladmi  
  Prepojená dátová štruktúra zoznamu v C ++ s ilustráciou  
  Skrytý zoznam súborov a ďalších zbierok v Jave