Povezani seznam v Javi - Implementacija povezanega seznama in primeri Java

linked list java linked list implementation java examples

Preizkusite Naš Instrument Za Odpravo Težav

Izberite Operacijski Sistem Izberite Program Projekcije (Neobvezno)

Opišite Svoj Problem

Ta vadnica pojasnjuje, kaj je struktura podatkov povezanega seznama v Javi in kako ustvariti, inicializirati, implementirati, preusmeriti, razveljaviti in razvrstiti seznam povezanih Java:

V Javi je LinkedList podatkovna struktura, ki elemente shranjuje na nenehni lokaciji. Gre za linearno strukturo podatkov.

Vsak podatkovni element se imenuje 'vozlišče' in vsako vozlišče ima podatkovni in naslovni del. Naslovni del shrani povezavo do naslednjega vozlišča na seznamu LinkedList.

=> Obiščite tukaj in si oglejte serijo Java Training for All.

Povezani seznam v Javi

Kaj se boste naučili:

LinkedList v Javi
Zaključek
- Priporočeno branje

LinkedList v Javi

Spodaj je splošna postavitev LinkedList:

splošna postavitev LinkedList

Kot je prikazano v zgornji predstavitvi LinkedList, je vsak element v LinkedList 'vozlišče'. Vsako vozlišče ima dva dela, v prvem delu so podatki, v drugem delu pa je referenca ali kazalec ali naslov naslednjega vozlišča v povezanem seznamu.

spajanje razvrsti psevdokod c ++

Ta ureditev je potrebna, saj se podatki v LinkedListu, za razliko od Arrays, shranjujejo na nesosednjih lokacijah.

»Glava« LinkedList je kazalec, ki vsebuje naslov prvega elementa v LinkedList. Zadnje vozlišče na seznamu LinkedList je rep. Kot je prikazano na zgornji sliki, je naslovni del zadnjega vozlišča v LinkedList nastavljen na 'Null', kar pomeni konec LinkedList.

Zgornji diagram predstavlja ' Enotno povezan seznam ”, Ki v naslovu LinkedList shrani naslov samo naslednjega vozlišča.

Obstaja še ena različica, znana kot Dvojno povezan seznam ”Katerega vsako vozlišče ima tri dele:

Naslov ali sklic ali kazalec na prejšnji element v LinkedList.
Podatkovni del
Naslov ali referenca ali kazalnik na naslednji element v povezanem seznamu.

Prejšnji naslov prvega elementa v seznamu LinkedList bo nastavljen na Null, medtem ko je naslednji kazalec zadnjega elementa na seznamu LinkedList nastavljen na Null.

Predstavitev dvojno povezanega seznama:

dvojno povezan seznam

Kot je prikazano v zgornji predstavitvi, ima vsako vozlišče na dvojno povezanem seznamu kazalce na prejšnje in naslednje vozlišče (torej predstavljeno brez puščic). Prejšnji kazalec prvega vozlišča kaže na nič, naslednji kazalec zadnjega vozlišča pa na nič.

V tej vadnici LinkedList bomo obravnavali večinoma posamezno povezan seznam. O dvojno povezanem seznamu bomo razpravljali v naši naslednji vadnici.

Razred Java LinkedList

V Javi je povezan seznam izveden z “ LinkedList ”Razred. Ta razred spada v java.util ”Paket. Razred LinkedList izvaja vmesnike List in Deque in podeduje razred AbstractList.

Spodaj je navedena hierarhija razredov razreda LinkedList.

hierarhija razreda razreda LinkedList

Zgornji diagram prikazuje hierarhijo razreda LinkedList. Kot je prikazano, razred LinkedList izvaja vmesnika List in Deque.

Kot smo že omenili, je razred LinkedList del “ java.util ”Paket. Zato bi morali v svojem programu uporabljati razred LinkedList, tako da v svoj program vključite enega od naslednjih stavkov.

import java.util.*;

Ali

import java.util.LinkedList;

Na podlagi zgornje hierarhije je tipična definicija razreda LinkedList naslednja:

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

Spodaj so navedene nekatere značilnosti razreda LinkedList, ki si jih morate zapomniti:

Ta razred ni sinhroniziran.
Omogoča podvojene vrednosti.
Ohrani vrstni red vstavljanja.
Ker med premikanjem elementov ni treba premikati, je manipulacija z elementi v njem hitrejša.
Ta razred se lahko uporablja za izvedbo sklada, čakalne vrste in seznama.

Kako ustvariti povezan seznam v Javi

Preden nadaljujemo z ustvarjanjem povezanega seznama v Javi, se najprej pogovorimo o vozlišču povezanega seznama v Javi.

Kot smo že omenili, je povezan seznam sestavljen iz vozlišč. Tako lahko v Javi LinkedList predstavimo kot razred, Node pa kot ločen razred. Zato se bo ta razred skliceval na tip Node.

To je prikazano spodaj:

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

Za ustvarjanje predmeta vrste LinkedList obstajata dva glavna konstruktorja, kot sledi:

# 1) LinkedList ()

Splošna sintaksa tega konstruktorja je:

LinkedList linkedList = new LinkedList();

Zgornji stavek ustvari prazen LinkedList.

Na primer,

LinkedList l_list = new LinkedList();

Tako boste ustvarili prazen povezan seznam z imenom l_list.

# 2) LinkedList (Zbirka c)

Splošna sintaksa je:

LinkedList linkedList = new LinkedList (Collection c);

Zgornja izjava ustvari LinkedList z elementi iz zbirke c kot začetnimi elementi.

Tako kot druge podatkovne strukture seznama, ki smo jih že videli, je tudi povezani seznam mogoče inicializirati z uporabo metode add, metode Arrays.asList () ali z uporabo konstruktorja z zbirko kot argumentom.

Izvedba povezanega seznama v Javi

Spodaj je prikazan preprost primer podatkovne strukture LinkedList v Javi. V tem primeru izvedbe bomo za inicializiranje objektov LinkedList uporabili metodo add in 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); } }

Izhod:

Vsebina prvega povezanega seznama: (10, 20, 30, 40, 50)
Vsebina drugega povezanega seznama: (rdeča, zelena, modra, modrozelena, magenta)

izvedba seznama, povezanega z rezultati

Zgornji program prikazuje ustvarjanje in inicializacijo LinkedList. Najprej ustvarimo LinkedList tipa Integer in ponudimo vrsto celih števil, pretvorjenih v seznam z uporabo metode asList kot začetne vrednosti za LinkedList.

Nato ustvarimo prazen LinkedList tipa String in nato z metodo add dodamo vrednosti v LinkedList.

Na koncu prikažemo oba predmeta LinkedList kot niz.

Prehod / tiskanje povezanega seznama v Javi

Če želite natisniti vsebino ali izvesti kakršne koli operacije na elementih LinkedList, morate prečkati njegove elemente. Te metode smo že videli v naših prejšnjih vajah. V tem poglavju bomo obravnavali primere vsakega v zvezi z LinkedList.

Uporaba for zanke

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  Izhod: 
 Elementi LinkedList, ki uporabljajo zanko for: 
Rdeča Zelena Modra
  
 Uporaba 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 + ' '); } } }  Izhod: 
 Elementi LinkedList, ki uporabljajo zanko forEach: 
Rdeča Zelena Modra
  
 Uporaba Iteratorja
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() + ' '); } } }  Izhod: 
 Vsebina povezanega seznama: 
Rdeča Zelena Modra Rumena
vprašanja in odgovori za tehnično podporo za bpo
  
 Metode LinkedList
 Razred LinkedList ponuja API, ki podpira različne metode za upravljanje povezanega seznama. Spodaj smo razčlenili metode v API-ju LinkedList.
  O glavnih operacijah / metodah bomo razpravljali v naslednjem poglavju. 
   Metoda Prototip Opis  
 
  Jasno prazno jasno () Izbriše vse elemente s seznama.  
 Dodaj logični dodatek (E e) Dodajte določen element na LinkedList  
  void add (int index, E element) Dodajte element pri danem indeksu v LinkedList  
  AddAll boolean addAll (zbirka c) Na koncu povezanega seznama doda elemente dane zbirke c.  
  logični addAll (indeks int, zbirka c) Doda elemente dane zbirke c na izbrani indeks v LinkedList  
  addFirst void addFirst (E e) Dodan element dodajte kot prvi element na LinkedList.  
  addLast void addLast (E e) Dani element dodajte na konec seznama.  
   Klon Klon predmeta () Naredi plitvo kopijo LinkedList  
  Vsebuje Logična vrednost vsebuje (predmet o) Preveri, ali seznam vsebuje določene elemente; če da, se vrne true.  
  padajočiIterator Iterator padajočeIterator () Vrne obratno urejeni iterator za LinkedList.  
  Element E element () Vrne element na vrhu seznama.  
  Pojdi E get (indeks int) Pridobi element na navedeni indeks.  
  getFirst E getFirst () Pridobi prvi element v LinkedList.  
  getLast E getLast () Pridobi zadnji element v LinkedList.  
  indeks Int indexOf (Predmet o) Poiščite indeks prvega pojavljanja danih elementov na seznamu in vrnite indeks. -1, če elementa ni mogoče najti.  
  lastIndexOf Int lastIndexOf (Predmet o) Vrne položaj zadnjega pojavljanja danega elementa v LinkedList; -1, če dani element ni prisoten  
  listIterator ListIterator listIterator (indeks int) Vrne listIterator iz podanega indeksa na povezanem seznamu.  
  Ponudba logična ponudba (E e) Dani element doda kot zadnji element (rep) v LinkedList.  
  ponudbaPrvi Logična ponudbaFirst (E e) Dani element doda kot prvi element v LinkedList.  
  offerLast Logična ponudbaZadnja (E e) Na koncu LinkedList dodajte dani element e.  
  Pokukajte E pokukajte () Vrne glavo seznama, ne da bi ga odstranil.  
  pokukajtePrvi E peekFirst () Vrne prvi element na seznamu. vrne nič, če je seznam prazen.  
  peekZadnje E peekLast () Vrne zadnji element ali nič, če je seznam prazen. Elementa ne izbriše.  
  Anketa E anketa () Vrne glavo povezanega seznama in ga tudi odstrani.  
  anketaPrvi E anketaPrvi () Vrne in izbriše prvi element na seznamu; vrne nič, če je seznam prazen.  
  anketaLast E-anketaZadnja () Vrne in izbriše zadnji element na seznamu; vrne nič, če je seznam prazen.  
  Pop E pop () Pokaže element iz predstavitve sklada LinkedList.  
  Potisni Prazen potisk (E e) Potisne ali vstavi element v predstavitev sklada LinkedList.  
  Odstrani E odstrani () Odstrani in vrne glavo povezanega seznama.  
  E odstrani (indeks int) Izbriše element v danem indeksu iz LinkedList.  
  logično odstranjevanje (objekt o) Izbriše prvi pojav danega elementa iz LinkedList.  
  odstrani najprej E removeFirst () Vrne in izbriše prvi element s seznama.  
  removeFirstOccurence boolean removeFirstOccurrence (Predmet o) Izbriše prvi pojav danega elementa s seznama, ko se seznam premika od glave do repa.  
  removeLast E removeLast () Vrne zadnji element v LinkedList in ga tudi izbriše.  
  removeLastOccurence boolean removeLastOccurrence (objekt o) Odstrani zadnji pojav danega elementa s seznama LinkedList pri prehodu od glave do repa  
  Nastavite E set (indeks int, element E) Nastavi dani element na dani indeks. Nadomešča trenutni element z novim.  
  Velikost Int velikost () Vrne velikost ali število elementov v povezanem seznamu  
  toArray Object () toArray () Pretvori LinkedList v matriko, ki vsebuje vse elemente seznama v pravilnem zaporedju  
  T () doArray (T () a) Pretvori LinkedList v polje z vrsto izvajalnega okolja, enako kot argument a.  
 
 
  Spodnji program Java prikazuje različne metode, ki smo jih navedli zgoraj. 
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)); } } Izhod: 
 Povezani seznam: (A, B, C, D, G, E, F) 
Povezan seznam po dodajanju vsebine ArrayList: (A, B, C, D, G, E, F, H, I) 
Po brisanju povezan seznam: (C, D, E, F, H) 
Seznam ne vsebuje elementa „G“ 
Velikost povezanega seznama = 5 
Element vrne get (): F 
Povezan seznam po spremembi: (C, D, E, J, H) 
Matrika, pridobljena s povezanega seznama: (C, D, E, J, H)
  
 Zgornji program prikazuje različne metode razreda LinkedList. Najprej razglasimo LinkedList tipa String. Nato uporabimo različne različice metode add, kot so add, andFirst, addLast, addAll itd., Da LinkedList zapolnimo z vrednostmi.
 Tu lahko element dodamo neposredno na koncu seznama ali ga dodamo na določenem mestu na seznamu.
 Uporabljamo tudi metodo addFirst za dodajanje elementa na začetku seznama in addLast za dodajanje elementa na koncu seznama. Nato na LinkedListu izvedemo odstranjevalne operacije, kot so remove, removeFirst, removeLast itd.
 Za metodo odstranjevanja lahko določimo element, ki ga želimo odstraniti, ali indeks ali položaj v LinkedList, na katerem naj se element odstrani. Metodi removeFirst in removeLast odstranita prvi oziroma zadnji element s seznama.
 Nato po seznamu poiščemo določen element z uporabo metode vsebuje. Nato z metodo size () pridobimo velikost ali dolžino LinkedList. Nato z metodami get / set pridobimo vrednost pri določenem indeksu na seznamu in nato zamenjamo vrednost na določenem mestu na seznamu.
  Na koncu pretvorimo LinkedList v matriko z uporabo metode toArray. 
 Povratno povezan seznam v Javi
 Za razveljavitev povezanega seznama v Javi uporabimo metodo “descendingIterator ()”, ki vrne povratni iterator za seznam. Nato lahko s tem iteratorjem prehodimo elemente seznama in prikaza.
  Spodnji program obrne povezani seznam z uporabo metode 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() + ' '); } } }  Izhod: 
 Povezani seznam: (Puna, Mumbaj, Nagpur) 
Povezani seznam v obratnem vrstnem redu: 
Nagpur Mumbai Pune
  
 V zgornjem programu razglasimo povezan seznam in ga nato natisnemo. Nato dobimo obratni iterator in nato z njim prestopimo skozi seznam in prikažemo vsak element. Rezultat prikazuje povezano vsebino seznama, najprej v vrstnem redu dodajanja elementov, nato pa rezultat prikazuje vsebino v obratnem vrstnem redu.
 Razvrsti povezani seznam v Javi
 Predmete razreda LinkedList je mogoče razvrstiti z metodo Collections.sort (). Ta metoda ponuja dve različici z ali brez uporabe primerjalnika. Ko je metoda Collections.sort () poklicana brez primerjalnika, je zbirka razvrščena po naravnem vrstnem redu.
 Ko primerjalnik se uporablja s to metodo, lahko določimo lastna merila za razvrščanje s preglasitvijo metode compareTo.
  Spodnji program Java razvrsti LinkedList s pomočjo Collections.sort (). Tu razvrščamo polja z naravnim urejanjem in s primerjalnikom. 
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); } } Izhod: 
 Original LinkedList (nesortirano): (januar, februar, marec, april, maj, junij) 
LinkedList (razvrščeno po naravnem vrstnem redu): (april, februar, januar, junij, marec, maj) 
LinkedList (razvrščeno s primerjalnikom): (april, februar, januar, junij, marec, maj)
  
 Odstrani dvojnike
 Če želite odstraniti dvojnike, morate prečkati vsako vozlišče in ga primerjati z naslednjim vozliščem. Če sta obe vozlišči enaki, eno vozlišče preskočimo in se premaknemo na drugo.
 Na ta način bomo po prehodu vsakega vozlišča in znebitvi podvojenih vozlišč dobili rezultatski seznam brez podvojenih elementov.
  Spodaj je program Java za odstranjevanje dvojnikov. 
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(); } }  Izhod: 
 Prvotni seznam povezav: 
1 1 2 3 5 2 1 1 
LinkedList po odstranitvi dvojnikov: 
1 2 3 5
  
 V zgornjem programu imamo povezan razred seznama, ustvarjen za odstranjevanje dvojnikov. Za definiranje vsakega vozlišča imamo tudi razred. Z drugimi besedami, vozlišča na seznamu so predmeti tega vozlišča razreda. Obstaja metoda za dodajanje vozlišča na povezani seznam.
 Nato v metodi removeDuplicate prehodimo vsako vozlišče na povezanem seznamu, začenši od glave in primerjamo vsako naslednje vozlišče za dvojnik. Če najdete dvojnik, preskočimo to vozlišče in nadaljujemo do naslednjega vozlišča.
 Na ta način je ist zgrajen s preskakovanjem podvojenih vozlišč in spremenjeni seznam se natisne z metodo print ().
 Krožno povezan seznam v Javi
 Krožno povezan seznam je seznam, katerega rep ali zadnje vozlišče je povezano nazaj na glavo ali prvo vozlišče.
  Spodnji diagram prikazuje krožno povezan seznam v Javi. 
  
 Kot je prikazano na zgornjem diagramu, naslovni del zadnjega vozlišča ali repa povezanega seznama ni nastavljen na nič. Namesto tega kaže nazaj na prvo vozlišče ali glavo seznama in tako tvori krožno povezan seznam.
  Spodnji program izvaja krožno povezan seznam, v katerem moramo manipulirati s posameznimi vozlišči povezanega seznama. 
programska oprema, napisana v jeziku c ++
 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(); } }  Izhod: 
 Vozlišča krožno povezanega seznama: 
10 20 30 40
  
 Java 8 LinkedList
 Čeprav v razredu LinkedList v Javi 8 ni posebej dodanih nobenih funkcij, je kljub temu uvedel tokove za obdelavo podatkov.
  Spodnji program prikazuje uporabo toka Java 8 za prikaz povezanega seznama. 
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); } } Izhod: 
 Vsebina LinkedList: 
Mreža 
Zelena 
Modra 
Cyan 
Magenta
  
 Pogosto zastavljena vprašanja
  V # 1) Kdaj se v Javi uporablja povezani seznam? 
  Odgovor: Ker je pri operacijah spreminjanja hitrejši od zbirk, kot je ArrayList, ga je treba uporabljati v aplikacijah, ki zahtevajo pogoste operacije dodajanja / brisanja. Za aplikacije, ki imajo večinoma samo bralne podatke, je mogoče uporabiti ArrayList ali podobne zbirke.
  Q # 2)  Kaj je ListNode? 
  Odgovor: ListNode je osnovni razred, povezan s povezanim seznamom v Javi in predstavlja informacije, povezane z enim samim elementom ali vozliščem. Vsako ListNode je sestavljeno iz podatkov in kazalca ali sklica na naslednji element.
  Q # 3)  Ali povezani seznam dovoljuje ničelne vrednosti? 
  Odgovor: Da, povezani seznam omogoča poljubno število ničelnih vrednosti.
  Q # 4)  Kakšne so prednosti povezanega seznama? 
  Odgovor: Nekatere prednosti so: 
  Manipulacijske operacije, kot so dodajanje in brisanje, so pri tem hitrejše.
 Za povezani seznam ni treba predhodno dodeliti pomnilnika, kar ima za posledico učinkovito uporabo pomnilnika.
 Omogoča hitrejši čas dostopa in brez dodatnih stroškov za pomnilnik in ga je mogoče stalno razširiti.
 Je dinamična podatkovna struktura
 Raste in se skrči v času izvajanja, odvisno od dodanih ali izbrisanih vrednosti.
 
  V # 5)  Kakšna je uporaba povezanega seznama? 
  Odgovor: Uporablja se večinoma v naslednjih aplikacijah: 
  Za izvajanje funkcije »razveljavi« v programski opremi, kot so MS-Word, Photoshop itd.
 Za izvajanje podatkovnih struktur, kot sta sklad in vrsta.
 Grafe lahko izvajamo tudi s pomočjo povezanega seznama.
 Za zgoščevanje vedrov je mogoče vsako vedro implementirati kot povezan seznam.
 
  V # 6)  Kakšne so omejitve povezanega seznama? 
  Odgovor: Nekatere omejitve so: 
  Z dodatnim kazalcem, ki vsebuje referenco naslednjega elementa v vsakem vozlišču, je uporabljeni pomnilnik veliko več kot polja.
 To je natančno zaporedno dostopna podatkovna struktura, zato je treba vozlišča povezanega seznama vedno brati od začetka.
 Težko ga je premakniti nazaj, zlasti po posamezno povezanih seznamih.
 Ker so vozlišča shranjena na neomejenih lokacijah, je čas, potreben za dostop, lahko velik.
 
 Zaključek
 V tej vadnici smo se naučili osnovne strukture podatkov povezanega seznama. Nato smo se premaknili na razred java.util.LinkedList, ki je na voljo v Javi. Podrobno smo razpravljali o tem razredu, vključno z njegovimi konstruktorji, metodami itd.
 Razpravljali smo tudi o nekaterih posebnih operacijah, povezanih s povezanimi seznami, kot so razvrščanje, obračanje seznama, odstranjevanje dvojnikov, krožno povezan seznam itd.
   V naslednji vadnici bomo razpravljali o posebnostih dvojno povezanega seznama.  
  => Tukaj si oglejte celoten vodnik za učenje Java.  
  Priporočeno branje
    Dvojno povezan seznam v Javi - primeri izvajanja in kode  
  Seznam Java - Kako ustvariti, inicializirati in uporabiti seznam v Javi  
  Metode seznama Java - Razvrsti seznam, Vsebuje, Dodaj, Dodaj, Odstrani  
  Binarni algoritem iskanja v Javi - implementacija in primeri  
  Razvrstitev vstavitve v Javi - Algoritem razvrščanja vstavkov in primeri  
  Vadnica Java vmesnika in abstraktnega razreda s primeri  
  Povezana podatkovna struktura seznama v jeziku C ++ z ilustracijo  
  Prikriti seznam v matriko in druge zbirke v Javi