Povezani popis u Javi - Primjena povezanog popisa i primjeri Java

linked list java linked list implementation java examples

Isprobajte Naš Instrument Za Uklanjanje Problema

Odaberite Operativni Sustav Odaberite Program Projekcije (Po Želji)

Opišite Svoj Problem

Ovaj vodič objašnjava što je struktura podataka povezanih popisa u Javi i kako stvoriti, pokrenuti, implementirati, preokrenuti, preokrenuti i razvrstati Java povezani popis:

U Javi, LinkedList je struktura podataka koja pohranjuje elemente na nesusjedno mjesto. To je linearna struktura podataka.

Svaka se podatkovna stavka naziva ‘čvor’ i svaki čvor ima podatkovni i adresni dio. Adresni dio pohranjuje vezu do sljedećeg čvora u LinkedListu.

=> Posjetite ovdje da biste vidjeli seriju Java treninga za sve.

Povezani popis na Javi

Što ćete naučiti:

LinkedList u Javi
Zaključak
- Preporučena literatura

LinkedList u Javi

Slijedi opći izgled LinkedList-a:

opći izgled LinkedList-a

Kao što je prikazano u gornjem prikazu LinkedList-a, svaka je stavka u LinkedListu „Čvor“. Svaki čvor ima dva dijela, prvi dio pohranjuje podatke, a drugi dio ima referencu ili pokazivač ili adresu sljedećeg čvora u LinkedListu.

ispitivanje opterećenja vs ispitivanje performansi vs testiranje naprezanja

Ovaj je aranžman neophodan jer se podaci u LinkedListu pohranjuju na nesusjednim lokacijama, za razliku od Arraysa.

'Glava' LinkedList-a je pokazivač koji sadrži adresu prvog elementa u LinkedList-u. Posljednji čvor na LinkedListu je rep. Kao što je prikazano na gornjoj slici, adresni dio zadnjeg čvora u LinkedListu postavljen je na 'Null' što označava kraj LinkedList-a.

Gornji dijagram predstavlja ' Popis s jednom vezom ”Koji pohranjuje adresu samo sljedećeg čvora u LinkedListu.

Postoji još jedna verzija poznata kao „ Popis dvostruko povezanih ”Čiji svaki čvor ima tri dijela:

Adresa ili referenca ili pokazivač na prethodni element u LinkedListu.
Dio podataka
Adresa ili referenca ili pokazivač na sljedeći element u LinkedListu.

Prethodna adresa prvog elementa u LinkedListu bit će postavljena na Null, dok je sljedeći pokazivač na Last element u LinkedListu postavljen na Null.

Zastupljenost dvostruko povezane liste:

dvostruko povezana lista

Kao što je prikazano u gornjem prikazu, svaki čvor na dvostruko povezanom popisu ima pokazivače na svoj prethodni i sljedeći čvor (tako predstavljeni bez strelica). Prethodni pokazivač prvog čvora pokazuje na nulu, dok sljedeći pokazivač zadnjeg čvora pokazuje na nulu.

U ovom uputstvu za LinkedList uglavnom ćemo se baviti pojedinačno povezanim popisom. O dvostruko povezanom popisu razgovarat ćemo u sljedećem vodiču.

Razred Java LinkedList

U Javi je povezani popis implementiran pomoću ' LinkedList ”Razred. Ova klasa pripada „ java.util ”Paket. Klasa LinkedList implementira sučelja List i Deque i nasljeđuje klasu AbstractList.

Slijedi hijerarhija klase klase LinkedList.

hijerarhija razreda klase LinkedList

Gornji dijagram prikazuje hijerarhiju klase LinkedList. Kao što je prikazano, klasa LinkedList implementira sučelja List i Deque.

Kao što je već spomenuto, klasa LinkedList dio je „ java.util ”Paket. Stoga biste trebali moći koristiti klasu LinkedList u svom programu tako što ćete u svoj program uključiti jednu od sljedećih izjava.

import java.util.*;

Ili

import java.util.LinkedList;

Dakle, na temelju gornje hijerarhije, tipična definicija klase LinkedList je sljedeća:

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

U nastavku su navedene neke od karakteristika klase LinkedList koje biste trebali zapamtiti:

Ova klasa nije sinkronizirana.
Omogućuje dvostruke vrijednosti.
Zadržava redoslijed umetanja.
Kako se elementi ne smiju pomicati tijekom kretanja, manipulacija elementima u njemu je brža.
Ova se klasa može koristiti za implementaciju stoga, reda i popisa.

Kako stvoriti povezani popis u Javi

Prije nego što prijeđemo na stvaranje povezanog popisa na Javi, prvo razgovarajmo o čvoru povezanog popisa na Javi.

Kao što je već rečeno, povezani popis sastoji se od čvorova. Tako u Javi LinkedList možemo predstaviti kao klasu sa svojim Nodeom kao zasebnu klasu. Stoga će ova klasa imati referencu na tip Node.

To je prikazano kao dolje:

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 stvaranje objekta tipa LinkedList, postoje dva glavna konstruktora, kako slijedi:

# 1) LinkedList ()

Općenita sintaksa ovog konstruktora je:

LinkedList linkedList = new LinkedList();

Gornja izjava stvara prazan LinkedList.

Na primjer,

LinkedList l_list = new LinkedList();

Ovo će stvoriti prazan povezani popis pod nazivom l_list.

# 2) LinkedList (Zbirka c)

Općenita sintaksa je:

LinkedList linkedList = new LinkedList (Collection c);

Gornja izjava stvara LinkedList s elementima iz zbirke c kao početnim elementima.

Poput ostalih struktura podataka popisa koje smo već vidjeli, povezani popis također se može inicijalizirati metodom add, metodom Arrays.asList () ili upotrebom konstruktora s kolekcijom kao argumentom.

Implementacija povezanog popisa u Javi

Slijedi jednostavni primjer strukture podataka LinkedList u Javi. U ovom primjeru implementacije koristit ćemo metodu add i metodu asList za inicijalizaciju objekata LinkedList.

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

Izlaz:

Sadržaj prvog povezanog popisa: (10, 20, 30, 40, 50)
Sadržaj drugog povezanog popisa: (crvena, zelena, plava, cijan, magenta)

implementacija popisa povezanih s rezultatima

Gornji program prikazuje stvaranje i inicijalizaciju LinkedList-a. Prvo stvorimo LinkedList tipa Integer i pružamo niz Integers pretvorenih u popis koristeći asList metodu kao početne vrijednosti za LinkedList.

Dalje, kreiramo prazan LinkedList tipa String, a zatim pomoću metode add dodamo vrijednosti LinkedListu.

Konačno, prikazujemo oba objekta LinkedList kao niz.

Prijelaz / ispis povezanog popisa u Javi

Da biste ispisali sadržaj ili izvršili bilo kakve radnje na elementima LinkedList-a, morate se kretati kroz njegove elemente. Ove smo metode već vidjeli u našim prethodnim vodičima. U ovom ćemo odjeljku razgovarati o primjerima svakog od njih u vezi s LinkedListom.

Korištenje for petlje

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  Izlaz: 
 Elementi LinkedList-a koji koriste petlju for: 
Crvena Zelena Plava
  
 Korištenje 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 + ' '); } } }  Izlaz: 
 Elementi LinkedList koji koriste forEach petlju: 
Crvena Zelena Plava
  
 Korištenje Iteratora
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() + ' '); } } }  Izlaz: 
 Sadržaj povezanog popisa: 
Crvena Zelena Plava Žuta
generator slučajnih brojeva 0-1
  
 Metode LinkedList
 Klasa LinkedList pruža API koji podržava razne metode za manipulaciju povezanim popisom. Metode smo tabelarizirali u API-ju LinkedList u nastavku.
  O glavnim operacijama / metodama razgovarat ćemo u sljedećem odjeljku. 
   Metoda Prototip Opis  
 
  Čisto void clear () Briše sve elemente s popisa.  
 Dodati logički dodatak (E e) Dodajte navedeni element na LinkedList  
  void add (int indeks, E element) Dodajte element na zadani indeks u LinkedList  
  Dodaj Sve boolean addAll (Zbirka c) Dodaje elemente zadane zbirke c na kraju LinkedList-a.  
  logički addAll (indeks int, zbirka c) Dodaje elemente dane zbirke c na navedenom indeksu u LinkedListu  
  addFirst void addFirst (E e) Dodajte zadani element kao prvi element na LinkedList.  
  addLast void addLast (E e) Dodajte zadani element na kraj popisa.  
   Klon Klon objekta () Izrađuje plitku kopiju LinkedList-a  
  Sadrži Boolean sadrži (objekt o) Provjerava sadrži li popis određene elemente; ako da, vraća se istina.  
  silazniIterator Iterator silaznoIterator () Vraća obrnuto poredani iterator za LinkedList.  
  Element E element () Vraća element na čelu popisa.  
  Dobiti E get (int indeks) Dobiva element po navedenom indeksu.  
  getFirst E getFirst () Dohvaća prvi element u LinkedListu.  
  getLast E getLast () Dohvaća zadnji element u LinkedListu.  
  indexOf Int indexOf (objekt o) Pronađite indeks prvog pojavljivanja danih elemenata na popisu i vratite indeks. -1 ako element nije pronađen.  
  lastIndexOf Int lastIndexOf (objekt o) Vraća položaj zadnjeg pojavljivanja datog elementa u LinkedList; -1 ako zadani element nije prisutan  
  listIterator ListIterator listIterator (int indeks) Vraća listIterator iz navedenog indeksa na povezanom popisu.  
  Ponuda logička ponuda (E e) Dodaje dati element kao posljednji element (rep) u LinkedList.  
  ponudaPrvo Logička ponudaFirst (E e) Dodaje dati element kao prvi element u LinkedList.  
  ponudaPosljednja Booleova ponudaPosljednja (E e) Dodajte zadani element e na kraj LinkedList-a.  
  Zaviri E zaviriti () Vraća glavu popisa bez uklanjanja.  
  zaviritiPrvo E peekFirst () Vraća prvi element na popisu. vraća nulu ako je popis prazan.  
  zaviritiLast E peekLast () Vraća zadnji element ili nulu ako je popis prazan. Ne briše element.  
  Anketa E anketa () Vraća glavu LinkedList-a i također je uklanja.  
  anketaPrvo E-anketaPrvo () Vraća i briše prvi element s popisa; vraća nulu ako je popis prazan.  
  anketaPosljednja E-anketaPosljednja () Vraća i briše posljednji element na popisu; vraća nulu ako je popis prazan.  
  Pop E pop () Iskače element iz predstavljanja sloga LinkedList.  
  Gurnuti Prazno guranje (E e) Gura ili ubacuje element u prikaz steka LinkedList-a.  
  Ukloniti E ukloni () Uklanja i vraća glavu povezanog popisa.  
  E ukloni (int indeks) Briše element s navedenim indeksom s LinkedList-a.  
  logičko uklanjanje (objekt o) Briše prvu pojavu datog elementa s LinkedList-a.  
  uklonitiPrvo E removeFirst () Vraća i briše prvi element s popisa.  
  removeFirstOccurence boolean removeFirstOccurrence (objekt o) Briše prvu pojavu datog elementa s popisa kada se popis prelazi od glave do repa.  
  removeLast E removeLast () Vraća zadnji element u LinkedListu i također ga briše.  
  removeLastOccurence boolean removeLastOccurrence (objekt o) Uklanja posljednju pojavu datog elementa s LinkedList-a kada se pređe od glave do repa  
  Postavi E skup (indeks int, E element) Postavlja zadani element na zadani indeks. Zamjenjuje trenutni element s novim.  
  Veličina Int veličina () Vraća veličinu ili broj elemenata u LinkedListu  
  toArray Objekt () uArray () Pretvara LinkedList u niz koji sadrži sve elemente popisa u ispravnom slijedu  
  T () doArray (T () a) Pretvara LinkedList u niz s vrstom izvođenja koja je ista kao argument a.  
 
 
  Sljedeći Java program prikazuje razne metode koje smo gore naveli. 
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)); } } Izlaz: 
 Povezani popis: (A, B, C, D, G, E, F) 
Povezani popis nakon dodavanja sadržaja ArrayList: (A, B, C, D, G, E, F, H, I) 
Povezani popis nakon brisanja: (C, D, E, F, H) 
Popis ne sadrži element 'G' 
Veličina povezanog popisa = 5 
Element vratio get (): F 
Povezani popis nakon promjene: (C, D, E, J, H) 
Niz dobiven sa povezanog popisa: (C, D, E, J, H)
  
 Gornji program prikazuje razne metode klase LinkedList. Prvo deklariramo LinkedList tipa String. Zatim koristimo razne verzije metode dodavanja poput add, andFirst, addLast, addAll, itd. Da bismo LinkedList popunili vrijednostima.
 Ovdje možemo dodati element izravno na kraj popisa ili ga dodati na određeno mjesto na popisu.
 Također koristimo metodu addFirst za dodavanje elementa na početku popisa i addLast za dodavanje elementa na kraju popisa. Zatim izvodimo operacije uklanjanja na LinkedListu poput remove, removeFirst, removeLast itd.
 Za metodu uklanjanja možemo odrediti element koji se uklanja ili možemo odrediti indeks ili poziciju u LinkedListu na kojem će se element ukloniti. Metode removeFirst i removeLast uklanjaju prvi i zadnji element s popisa.
 Zatim pretražujemo popis za određeni element pomoću metode contains. Zatim koristimo metodu size () za dohvaćanje veličine ili duljine LinkedList-a. Tada koristimo metode get / set za dohvaćanje vrijednosti na određenom indeksu na popisu, a zatim zamjenjujemo vrijednost na određenom mjestu na popisu.
  Na kraju, pretvaramo LinkedList u Array metodom toArray. 
 Obrnuti povezani popis u Javi
 Da bismo preokrenuli povezani popis u Javi, koristimo metodu 'descendingIterator ()' koja vraća obrnuti iterator za popis. Tada pomoću ovog iteratora možemo prelaziti kroz popis i prikazati elemente.
  Program u nastavku preokreće povezani popis pomoću 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() + ' '); } } }  Izlaz: 
 Povezani popis: (Pune, Mumbai, Nagpur) 
Povezani popis obrnutim redoslijedom: 
Nagpur Mumbai Pune
  
 U gornjem programu deklariramo povezani popis, a zatim ga ispisujemo. Tada dobivamo obrnuti iterator i zatim koračamo kroz popis pomoću njega i prikazujemo svaki element. Izlaz prikazuje povezani sadržaj popisa, prvo redoslijedom dodaju se elementi, a zatim izlaz prikazuje sadržaj obrnutim redoslijedom.
 Poredaj povezani popis u Javi
 Objekti klase LinkedList mogu se sortirati metodom Collections.sort (). Ova metoda nudi dvije verzije sa ili bez upotrebe usporedbe. Kada se metoda Collections.sort () pozove bez usporedbe, zbirka se sortira prirodnim redoslijedom.
 Kada komparator koristi se s ovom metodom, možemo definirati vlastite kriterije sortiranja nadjačavanjem metode compareTo.
  Ispod navedeni Java program sortira LinkedList pomoću Collections.sort (). Ovdje sortiramo nizove koristeći prirodni poredak kao i pomoću usporedbe. 
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); } } Izlaz: 
 Izvorni LinkedList (nesortirano): (siječanj, veljača, ožujak, travanj, svibanj, lipanj) 
LinkedList (poredano prirodnim redoslijedom): (travanj, veljača, siječanj, lipanj, ožujak, svibanj) 
LinkedList (poredano pomoću usporedbe): (travanj, veljača, siječanj, lipanj, ožujak, svibanj)
  
 Ukloni duplikate
 Da biste uklonili duplikate, morate preći svaki čvor i usporediti ga sa sljedećim čvorom. Ako su oba čvora ista onda preskačemo jedan čvor i prelazimo na sljedeći.
 Na taj način, nakon što pređemo svaki čvor i riješimo se dupliciranih čvorova, dobit ćemo rezultantni popis koji nema dupliciranih elemenata.
  Dolje je dan Java program za uklanjanje duplikata. 
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(); } }  Izlaz: 
 Izvorni povezani popis: 
1 1 2 3 5 2 1 1 
LinkedList nakon uklanjanja duplikata: 
1 2 3 5
  
 U gornjem programu imamo povezanu klasu popisa stvorenu za uklanjanje duplikata. Također imamo klasu za definiranje svakog čvora. Drugim riječima, čvorovi na popisu su objekti ovog čvora klase. Imamo metodu za dodavanje čvora na povezani popis.
 Zatim u metodi removeDuplicate prelazimo kroz svaki čvor na povezanom popisu počevši od glave i uspoređujemo svaki sljedeći čvor za duplikat. Ako se pronađe duplikat, preskačemo taj čvor i nastavljamo do sljedećeg čvora.
 Na taj se način ist gradi preskakanjem duplikata čvorova i mijenja se popis ispisuje metodom print ().
 Kružno povezani popis u Javi
 Kružno povezani popis je popis kojem su rep ili zadnji čvor povezani natrag na glavu ili prvi čvor.
  Dijagram ispod prikazuje popis kružnih veza u Javi. 
  
 Kao što je prikazano na gornjem dijagramu, adresni dio zadnjeg čvora ili repa povezanog popisa nije postavljen na nulu. Umjesto toga, usmjerava se na prvi čvor ili glavu popisa, čineći tako kružno povezan popis.
  Program u nastavku implementira kružni povezani popis u kojem moramo manipulirati pojedinačnim čvorovima povezanog popisa. 
 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(); } }  Izlaz: 
 Kružno povezani čvorovi popisa: 
10 20 30 40
  
 Java 8 LinkedList
 Iako u Java 8 više nema posebno dodanih klasa LinkedList, ona je i dalje uvela tokove za manipulaciju podacima.
  Program u nastavku prikazuje upotrebu Java 8 streama za prikaz LinkedList-a. 
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); } } Izlaz: 
 Sadržaj LinkedList-a: 
Neto 
Zelena 
Plava 
Cijan 
Magenta
  
implementacija reda prioriteta u javi
 Često postavljana pitanja
  P # 1) Kada se Povezani popis koristi u Javi? 
  Odgovor: Budući da je brži od zbirki poput ArrayList u operacijama modifikacije, trebao bi se koristiti u aplikacijama koje zahtijevaju česte operacije dodavanja / brisanja. Za programe koji imaju uglavnom podatke samo za čitanje mogu se koristiti ArrayList ili slične kolekcije.
  P # 2)  Što je ListNode? 
  Odgovor: ListNode je osnovna klasa povezana s povezanim popisom u Javi i predstavlja informacije povezane s jednim elementom ili čvorom. Svaki ListNode sastoji se od podataka i pokazivača ili reference na sljedeći element.
  3. pitanje)  Dopušta li povezani popis null vrijednosti? 
  Odgovor: Da, povezani popis dopušta bilo koji broj null vrijednosti.
  P # 4)  Koje su prednosti povezanog popisa? 
  Odgovor: Neke od prednosti su: 
  Operacije manipulacije poput dodavanja i brisanja su brže u njemu.
 Nije potrebno unaprijed dodijeliti memoriju za povezani popis, što rezultira učinkovitim korištenjem memorije.
 Omogućuje brže vrijeme pristupa i bez dodatnih troškova za memoriju, a može se proširiti u stalnom vremenu.
 To je dinamička struktura podataka
 Raste i smanjuje se tijekom izvođenja, ovisno o dodanim ili izbrisanim vrijednostima.
 
  5. pitanje)  Koja je primjena povezanog popisa? 
  Odgovor: Koristi se uglavnom u sljedećim aplikacijama: 
  Implementirati funkcionalnost poništavanja u softver poput MS-Word, Photoshop itd.
 Za implementaciju struktura podataka kao što su stog i red.
 Grafove možemo implementirati i pomoću povezanog popisa.
 Za raspršivanje segmenata, svaki se segment može implementirati kao povezani popis.
 
  P # 6)  Koja su ograničenja povezanog popisa? 
  Odgovor: Neka od ograničenja su: 
  S dodatnim pokazivačem koji sadrži referencu sljedećeg elementa u svakom čvoru, iskorištena memorija mnogo je više od nizova.
 Ovo je struktura podataka s strogo sekvencijalnim pristupom, stoga se čvorovi povezanog popisa moraju uvijek čitati od početka.
 Teško ga je prebaciti unatrag, posebno pojedinačno povezane liste.
 Budući da su čvorovi pohranjeni na nestalnim mjestima, vrijeme potrebno za pristup može biti veliko.
 
 Zaključak
 U ovom smo tutorijalu naučili osnovnu strukturu podataka povezanih popisa. Zatim smo prešli na klasu java.util.LinkedList koja se pruža na Javi. Detaljno smo raspravljali o ovoj klasi, uključujući njene konstruktore, metode itd.
 Također smo razgovarali o nekim posebnim operacijama povezanim s povezanim popisima poput sortiranja, preokretanja popisa, uklanjanja duplikata, kružno povezanog popisa itd.
   U našem sljedećem vodiču razgovarat ćemo o specifičnostima dvostruko povezanog popisa.  
  => Ovdje pogledajte Cjelokupni vodič za Java obuku.  
  Preporučena literatura
    Popis dvostruko povezanih na Javi - primjeri implementacije i koda  
  Popis Java - Kako stvoriti, inicijalizirati i koristiti popis na Javi  
  Metode Java popisa - Poredaj popis, Sadrži, Popis dodaj, Popis ukloni  
  Binarni algoritam pretraživanja u Javi - implementacija i primjeri  
  Sortiranje umetanja u Javi - Algoritam sortiranja umetanja i primjeri  
  Java sučelje i udžbenik klase sažetak sa primjerima  
  Povezana struktura podataka popisa na C ++ s ilustracijom  
  Tajni popis u niz i ostale zbirke u Javi