जावा में लिंक्ड सूची - लिंक्ड सूची कार्यान्वयन और जावा उदाहरण

linked list java linked list implementation java examples

यह ट्यूटोरियल बताता है कि जावा में लिंक्ड लिस्ट डेटा स्ट्रक्चर क्या है और जावा लिंक्ड लिस्ट को कैसे बनाएं, इनिशियलाइज़, इम्प्लीमेंट, ट्रैवर्स, रिवर्स और सॉर्ट करें:

जावा में, एक लिंक्डलिस्ट एक डेटा संरचना है जो तत्वों को गैर-सन्निहित स्थान पर संग्रहीत करता है। यह एक रैखिक डेटा संरचना है।

प्रत्येक डेटा आइटम को 'नोड' कहा जाता है और प्रत्येक नोड में एक डेटा भाग और एक पता भाग होता है। एड्रेस पार्ट लिंकडलिस्ट में अगले नोड के लिए लिंक स्टोर करता है।

=> सभी के लिए जावा प्रशिक्षण श्रृंखला देखने के लिए यहां जाएं।

जावा में लिस्टेड लिंक

आप क्या सीखेंगे:

लिंक्डलिस्ट जावा में
निष्कर्ष
- अनुशंसित पाठ

लिंक्डलिस्ट जावा में

नीचे दिए गए LinkedList का सामान्य लेआउट है:

लिंक्डलिस्ट का सामान्य लेआउट

जैसा कि लिंक्डलिस्ट के उपरोक्त प्रतिनिधित्व में दिखाया गया है, लिंक्डलिस्ट में प्रत्येक आइटम 'नोड' है। प्रत्येक नोड में दो भाग होते हैं, पहला भाग डेटा को संग्रहीत करता है और दूसरे भाग में लिंक्डलिस्ट में अगले नोड का एक संदर्भ या सूचक या पता होता है।

यह व्यवस्था आवश्यक है क्योंकि Arrays के विपरीत LinkedList में डेटा गैर-सन्निहित स्थानों में संग्रहीत किया जाता है।

के लिए काम करने के लिए सबसे बड़ी डेटा कंपनियों

लिंक्डलिस्ट का 'हेड' एक पॉइंटर होता है जिसमें लिंक्डलिस्ट में पहले तत्व का पता होता है। लिंक्डलिस्ट में आखिरी नोड पूंछ है। जैसा कि ऊपर चित्र में दिखाया गया है, लिंक्डलिस्ट में अंतिम नोड का पता हिस्सा लिंक्डलिस्ट के अंत का संकेत देते हुए 'नल' पर सेट है।

उपरोक्त आरेख ' एकल-लिंक की गई सूची 'जो लिंक्डलिस्ट में केवल अगले नोड के पते को संग्रहीत करता है।

एक और संस्करण है जिसे “ संदेह से जुड़ी सूची 'जिसके प्रत्येक नोड के तीन भाग हैं:

LinkedList में पिछले तत्व का पता या संदर्भ या सूचक।
डेटा भाग
LinkedList में अगले तत्व के लिए पता या संदर्भ या सूचक।

लिंक्डलिस्ट में पहले तत्व का पिछला पता नल को सेट किया जाएगा, जबकि लिंक्डलिस्ट में आखिरी तत्व का अगला पॉइंटर नल पर सेट है।

डबली लिंक्ड सूची का प्रतिनिधित्व:

दोगुनी लिंक की गई सूची

जैसा कि उपरोक्त प्रतिनिधित्व में दिखाया गया है, दोगुनी लिंक की गई सूची में प्रत्येक नोड में उसके पिछले और अगले नोड (इस प्रकार बिना तीर के प्रतिनिधित्व) के संकेत होते हैं। पहले नोड का पिछला पॉइंटर शून्य की ओर इंगित करता है जबकि अंतिम नोड का अगला पॉइंटर इंगित करता है।

इस लिंक्डलिस्ट ट्यूटोरियल में, हम ज्यादातर एकल लिंक की गई सूची से निपटेंगे। हम अपने अगले ट्यूटोरियल में दोगुनी लिंक की गई सूची पर चर्चा करेंगे।

जावा लिंक्डलिस्ट क्लास

जावा में, लिंक की गई सूची “द्वारा कार्यान्वित की जाती है लिंक्ड सूची ' कक्षा। यह वर्ग “ java.util ”पैकेज। लिंक्डलिस्ट क्लास लिस्ट और डीके इंटरफेस को लागू करती है और एब्सट्रेलिस्ट क्लास को इनहेरिट करती है।

नीचे दिए गए लिंक्डलिस्ट वर्ग के वर्ग पदानुक्रम है।

लिंक्डलिस्ट वर्ग के वर्ग पदानुक्रम

उपरोक्त आरेख लिंक्डलिस्ट वर्ग के पदानुक्रम को दर्शाता है। जैसा कि दिखाया गया है, लिंक्डलिस्ट वर्ग सूची और डीके इंटरफेस को लागू करता है।

जैसा कि पहले ही उल्लेख किया गया है, लिंक्डलिस्ट वर्ग 'का एक हिस्सा है java.util ”पैकेज। इसलिए आप अपने प्रोग्राम में लिंक्डइन क्लास को अपने प्रोग्राम में निम्न में से किसी एक कथन का उपयोग करने में सक्षम होना चाहिए।

import java.util.*;

या

import java.util.LinkedList;

तो उपरोक्त पदानुक्रम के आधार पर, लिंक्डलिस्ट वर्ग की एक विशिष्ट परिभाषा इस प्रकार है:

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

नीचे सूचीबद्ध लिंक्डलिस्ट वर्ग की कुछ विशेषताएं हैं जिन्हें आपको याद रखना चाहिए:

यह वर्ग सिंक्रनाइज़ नहीं है।
यह डुप्लिकेट मानों की अनुमति देता है।
निवेशन क्रम को बनाए रखता है।
चूंकि चलते समय तत्वों को स्थानांतरित करने की आवश्यकता नहीं होती है, इसलिए इसमें तत्वों का हेरफेर तेज होता है।
इस वर्ग का उपयोग स्टैक, कतार और सूची को लागू करने के लिए किया जा सकता है।

कैसे जावा में एक लिंक्ड सूची बनाने के लिए

जावा में लिंक लिस्ट बनाने के लिए आगे बढ़ने से पहले, आइए पहले जावा में एक लिंक्ड लिस्ट नोड पर चर्चा करें।

जैसा कि पहले ही चर्चा की गई है, एक लिंक की गई सूची में नोड्स होते हैं। इस प्रकार जावा में, हम एक लिंक्डलिस्ट को एक वर्ग के रूप में एक नोड के रूप में एक अलग वर्ग के रूप में प्रतिनिधित्व कर सकते हैं। इसलिए इस वर्ग के पास नोड प्रकार का संदर्भ होगा।

यह नीचे दिखाया गया है:

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

लिंक्डलिस्ट का एक प्रकार बनाने के लिए, दो मुख्य निर्माता निम्नानुसार हैं:

(1) लिंक्डलिस्ट ()

इस निर्माता के लिए सामान्य वाक्यविन्यास है:

LinkedList linkedList = new LinkedList();

उपरोक्त कथन एक खाली लिंक्डलिस्ट बनाता है।

उदाहरण के लिए,

LinkedList l_list = new LinkedList();

यह l_list नाम से एक रिक्त लिंक सूची बनाएगा।

# 2) लिंक्डलिस्ट (संग्रह सी)

सामान्य वाक्यविन्यास है:

LinkedList linkedList = new LinkedList (Collection c);

उपर्युक्त कथन संग्रह के तत्वों के साथ प्रारंभिक तत्वों के रूप में एक लिंक्डलिस्ट बनाता है।

अन्य सूची डेटा संरचनाओं की तरह जो हमने पहले ही देख लिया है, लिंक की गई सूची को जोड़ विधि, Arrays.asList () विधि का उपयोग करके या संग्रह के साथ कंस्ट्रक्टर का उपयोग तर्क के रूप में भी किया जा सकता है।

लिंक्ड सूची कार्यान्वयन जावा में

नीचे दिए गए जावा में लिंक्डलिस्ट डेटा संरचना का एक सरल उदाहरण है। कार्यान्वयन के इस उदाहरण में, हम 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); } }

आउटपुट:

पहले लिंक्डलिस्ट के विषय: [१०, २०, ३०, ४०, ५०]
दूसरे लिंक्डलिस्ट के विषय: [लाल, हरा, नीला, सियान, मैजेंटा]

आउटपुट-लिंक्ड सूची कार्यान्वयन

उपरोक्त कार्यक्रम लिंक्डलिस्ट के निर्माण और आरंभीकरण को दर्शाता है। सबसे पहले, हम प्रकार का एक लिंक्डलिस्ट बनाते हैं और लिंक्डलिस्ट के लिए प्रारंभिक मानों के रूप में एटलिस्ट पद्धति का उपयोग करके सूची में परिवर्तित किए गए पूर्णांक के एक सरणी प्रदान करते हैं।

अगला, हम स्ट्रिंग का एक खाली लिंक्डलिस्ट बनाते हैं और फिर ऐड विधि का उपयोग करते हुए, हम लिंक्डलिस्ट में मान जोड़ते हैं।

अंत में, हम दोनों लिंक्डलिस्ट ऑब्जेक्ट्स को एक स्ट्रिंग के रूप में प्रदर्शित करते हैं।

Traverse / Print Linked List जावा में

लिंक्डलिस्ट के तत्वों पर सामग्री को प्रिंट करने या किसी भी संचालन को करने के लिए, आपको इसके तत्वों को पार करना होगा। हमने इन तरीकों को अपने पिछले ट्यूटोरियल में पहले ही देख लिया है। इस भाग में, हम लिंक्डलिस्ट के संबंध में प्रत्येक के उदाहरणों पर चर्चा करेंगे।

लूप के लिए उपयोग करना

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  आउटपुट: 
 लूप के लिए उपयोग कर लिंक्डलिस्ट तत्व: 
लाल हरा नीला
  
 फोर लूप का उपयोग करना
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 + ' '); } } }  आउटपुट: 
 LinkedList तत्वों का उपयोग कर आगे लूप: 
लाल हरा नीला
  
 इटरेटर का उपयोग करना
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() + ' '); } } }  आउटपुट: 
 लिंक्ड सूची की सामग्री: 
लाल हरा नीला पीला
  
विंडोज़ 10 2018 के लिए सर्वश्रेष्ठ मुफ्त फ़ायरवॉल
 लिंक्डलिस्ट तरीके
 लिंक्डलिस्ट वर्ग एपीआई प्रदान करता है जो लिंक्ड सूची में हेरफेर करने के लिए विभिन्न तरीकों का समर्थन करता है। हमने नीचे लिंक्डलिस्ट एपीआई में विधियों को सारणीबद्ध किया है।
  हम निम्नलिखित अनुभाग में मुख्य संचालन / विधियों पर चर्चा करेंगे। 
   तरीका प्रोटोटाइप विवरण  
 
  स्पष्ट शून्य स्पष्ट () सूची से सभी तत्वों को हटाता है।  
 जोड़ना बूलियन ऐड (E e) लिंक्डलिस्ट में एक निर्दिष्ट तत्व जोड़ें  
  शून्य जोड़ (int index, E element) LinkedList में दिए गए इंडेक्स में तत्व जोड़ें  
  सभी जोड़ें बूलियन addAll (संग्रह सी) लिंक्डलिस्ट के अंत में दिए गए संग्रह c के तत्वों को जोड़ता है।  
  बूलियन AddAll (int index, Collection c) लिंक्डलिस्ट में निर्दिष्ट सूचकांक पर दिए गए संग्रह सी के तत्वों को जोड़ता है  
  AddFirst शून्य जोड़ (ई) लिंक्डलिस्ट में पहले तत्व के रूप में दिए गए तत्व को जोड़ें।  
  addLast शून्य ऐडलैस्ट (E e) सूची के अंत में दिए गए तत्व को जोड़ें।  
   क्लोन ऑब्जेक्ट क्लोन () लिंक्डलिस्ट की उथली प्रति बनाता है  
  शामिल बूलियन में शामिल (ऑब्जेक्ट ओ) जाँचता है कि सूची में निर्दिष्ट तत्व हैं या नहीं; यदि हाँ, तो सही है।  
  अवरोही Iterator descendingIterator () लिंक्डलिस्ट के लिए एक रिवर्स ऑर्डर किए गए पुनरावृत्ति रिटर्न देता है।  
  तत्त्व ई तत्व () सूची के प्रमुख पर तत्व देता है।  
  प्राप्त E get (int index) निर्दिष्ट सूचकांक पर तत्व प्राप्त करता है।  
  GetFirst ई getFirst () लिंक्डलिस्ट में पहले तत्व को पुनर्प्राप्त करता है।  
  अंतिम लो ई गेटलैस्ट () लिंक्डलिस्ट में अंतिम तत्व को पुनः प्राप्त करता है।  
  के सूचकांक Int indexOf (ऑब्जेक्ट ओ) सूची में दिए गए तत्वों की पहली घटना का सूचकांक ढूंढें और सूचकांक वापस करें। -1 अगर तत्व नहीं मिला।  
  lastIndexOf Int lastIndexOf (ऑब्जेक्ट ओ) लिंक्डलिस्ट में दिए गए तत्व की अंतिम घटना की स्थिति लौटाता है; -1 यदि दिया गया तत्व मौजूद नहीं है  
  सूची बनानेवाला सूची सूची सूची (अंतर सूचकांक) सूचीसूची को निर्दिष्ट सूची से लिंक्डलिस्ट में लौटाता है।  
  प्रस्ताव बूलियन पेशकश (ई ई) लिंक्डलिस्ट में दिए गए तत्व को अंतिम तत्व (पूंछ) के रूप में जोड़ता है।  
  ऑफ़रफ़र्स्ट बूलियन ऑफ़रफ़र्स्ट (E e) लिंक्डलिस्ट में पहले तत्व के रूप में दिए गए तत्व को जोड़ता है।  
  प्रस्ताव बूलियन ऑफ़रलैस्ट (E e) लिंक्डलिस्ट के अंत में दिए गए तत्व ई जोड़ें।  
  तिरछी ई झांकना () बिना हटाए सूची के प्रमुख को लौटाता है।  
  झांकना ई झांकना () सूची में पहला तत्व देता है। यदि सूची खाली है, तो अशक्त है।  
  झांकना ई पिकालास्ट () यदि सूची खाली है, तो अंतिम तत्व या नल लौटाता है। यह तत्व को नष्ट नहीं करता है।  
  मतदान ई चुनाव () लिंक्डलिस्ट का सिर लौटाता है और इसे हटा भी देता है।  
  प्रदुषण ई प्रदूषण सूची में पहले तत्व को लौटाता है और हटाता है; यदि सूची खाली है, तो अशक्त है।  
  प्रदूषक ई पोलास्ट () सूची में अंतिम तत्व देता है और हटाता है; यदि सूची खाली है, तो अशक्त है।  
  पॉप ई पॉप () लिंक्डलिस्ट के स्टैक प्रतिनिधित्व से तत्व को पॉप करता है।  
  धक्का दें शून्य धक्का (ई ई) लिंक्डलिस्ट के स्टैक प्रतिनिधित्व में एक तत्व को धक्का या सम्मिलित करता है।  
  हटाना ई निकालें () लिंक्डलिस्ट के प्रमुख को हटाता है और लौटाता है।  
  ई निकालें (इंट इंडेक्स) लिंक्डलिस्ट से दिए गए इंडेक्स में तत्व को हटाता है।  
  बूलियन निकालें (ऑब्जेक्ट ओ) लिंक्डलिस्ट से दिए गए तत्व की पहली घटना को हटाता है।  
  निकालें ई निष्कासन रिटर्न और सूची से पहला तत्व हटाता है।  
  removeFirstOccurence बूलियन निष्कासन सूची से दिए गए तत्व की पहली घटना को हटाता है जब सूची को सिर से पूंछ तक ट्रेस किया जा रहा है।  
  हटाएं E निष्कासन () लिंक्डलिस्ट में अंतिम तत्व देता है और इसे हटा भी देता है।  
  निष्कासन बूलियन निष्कासन लिंक्डलिस्ट से दिए गए तत्व की अंतिम घटना को हटाता है जब सिर से पूंछ तक ट्रेस किया जाता है  
  सेट ई सेट (इंट इंडेक्स, ई एलिमेंट) दिए गए तत्व को दिए गए इंडेक्स पर सेट करता है। वर्तमान तत्व को नए के साथ बदल देता है।  
  आकार Int आकार () लिंक्डलिस्ट में तत्वों का आकार या संख्या देता है  
  .अरे ऑब्जेक्ट [] toArray () उचित क्रम में सभी सूची तत्वों से युक्त सरणी के लिए लिंक्डलिस्ट में रूपांतरित करता है  
  T [] toArray (T [] a) लिंकडैमिस्ट को एक सरणी में रनटाइम प्रकार के साथ तर्क ए के रूप में जोड़ता है।  
 
 
  नीचे जावा प्रोग्राम विभिन्न तरीकों को प्रदर्शित करता है जिन्हें हमने ऊपर सूचीबद्ध किया है। 
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)); } } आउटपुट: 
 लिंक्ड सूची: [ए, बी, सी, डी, जी, ई, एफ] 
ArrayList सामग्री जोड़ने के बाद लिंक की गई सूची: [A, B, C, D, G, E, F, H, I] 
हटाए जाने के बाद लिंक की गई सूची: [C, D, E, F, H] 
सूची में 'G' तत्व नहीं है 
लिंक की गई सूची का आकार = 5 
तत्व प्राप्त करके लौटे (): एफ 
परिवर्तन के बाद लिंक की गई सूची: [C, D, E, J, H] 
लिंक की गई सूची से प्राप्त एरे: [सी, डी, ई, जे, एच]
  
 उपरोक्त कार्यक्रम लिंक्डलिस्ट वर्ग के विभिन्न तरीकों को प्रदर्शित करता है। सबसे पहले, हम स्ट्रिंग के लिंक्डलिस्ट की घोषणा करते हैं। फिर हम ऐडेड विधि के विभिन्न संस्करणों का उपयोग करते हैं, जैसे ऐड, और फ़र्स्ट, ऐडलैस्ट, ऐडऑल, आदि को लिंक्डलिस्ट को मूल्यों के साथ जोड़ने के लिए।
 यहां हम सूची के अंत में तत्व को सीधे जोड़ सकते हैं या सूची में निर्दिष्ट स्थान पर तत्व जोड़ सकते हैं।
 हम सूची की शुरुआत में एक तत्व जोड़ने के लिए और सूची के अंत में एक तत्व जोड़ने के लिए AddLast विधि का भी उपयोग करते हैं। फिर हम लिंक्डलिस्ट पर हटाए, हटाएं, हटाएं, हटाएं आदि जैसे लिंक ऑपरेशन करते हैं।
 हटाने की विधि के लिए, हम या तो निकाले जाने वाले तत्व को निर्दिष्ट कर सकते हैं या हम लिंक्डलिस्ट में सूचकांक या स्थिति को निर्दिष्ट कर सकते हैं जिस पर तत्व को हटाया जाना है। हटाने और हटाने की विधियाँ क्रमशः सूची में पहले और अंतिम तत्व को हटा देती हैं।
 फिर हम किसी विशेष तत्व के लिए सूची को खोजते हैं जिसमें विधि शामिल है। अगला, हम लिंक्डलिस्ट के आकार या लंबाई को पुनः प्राप्त करने के लिए आकार () विधि का उपयोग करते हैं। फिर हम सूची में किसी विशेष इंडेक्स पर मान प्राप्त करने के लिए / सेट विधियों का उपयोग करते हैं और फिर सूची में एक निर्दिष्ट स्थान पर एक मूल्य को प्रतिस्थापित करते हैं।
  अंत में, हम। विधि का उपयोग करके लिंक्डलिस्ट को एक ऐरे में परिवर्तित करते हैं। 
 जावा में रिवर्स लिंक्ड सूची
 जावा में एक लिंक की गई सूची को उलटने के लिए, हम 'descendingIterator ()' विधि का उपयोग करते हैं जो सूची के लिए एक रिवर्स पुनरावृत्ति देता है। हम सूची और प्रदर्शन तत्वों के माध्यम से पार करने के लिए इस पुनरावृत्ति का उपयोग कर सकते हैं।
  नीचे दिए गए कार्यक्रम 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() + ' '); } } }  आउटपुट: 
 लिंक्ड सूची: [पुणे, मुंबई, नागपुर] 
रिवर्स क्रम में सूचीबद्ध सूची: 
नागपुर मुंबई पुणे
  
 उपरोक्त कार्यक्रम में, हम एक लिंक की गई सूची की घोषणा करते हैं और फिर उसे प्रिंट करते हैं। फिर हमें एक रिवर्स इट्रीटर मिलता है और फिर इसका उपयोग करके सूची के माध्यम से कदम बढ़ाते हैं और प्रत्येक तत्व को प्रदर्शित करते हैं। आउटपुट लिंक की गई लिस्ट कंटेंट को दिखाता है, सबसे पहले उस एलिमेंट्स को जोड़ा जाता है और फिर आउटपुट कंटेंट को रिवर्स ऑर्डर में दिखाता है।
 जावा में एक लिंक की गई सूची को क्रमबद्ध करें
 लिंक्डलिस्ट क्लास ऑब्जेक्ट्स को Collections.sort () विधि का उपयोग करके सॉर्ट किया जा सकता है। यह विधि एक तुलनित्र का उपयोग किए बिना या उसके बिना दो संस्करण प्रदान करती है। जब कलेक्शंस.सॉर्ट () विधि को एक तुलनित्र के बिना कहा जाता है, तो संग्रह को प्राकृतिक क्रम में क्रमबद्ध किया जाता है।
 जब COMPARATOR इस पद्धति के साथ प्रयोग किया जाता है, हम तुलना पद्धति को ओवरराइड करके अपने स्वयं के छँटाई मानदंडों को परिभाषित कर सकते हैं।
  नीचे Java प्रोग्राम कलेक्शंस.सॉर्ट () का उपयोग करके एक लिंक्डलिस्ट को सॉर्ट करता है। यहां हम प्राकृतिक ऑर्डरिंग के साथ-साथ तुलनित्र का उपयोग करके एरेज को सॉर्ट करते हैं। 
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); } } आउटपुट: 
 मूल लिंक्डलिस्ट (अनसोल्ड): [जनवरी, फरवरी, मार्च, अप्रैल, मई, जून] 
लिंक्डलिस्ट (प्राकृतिक क्रम में क्रमबद्ध): [अप्रैल, फ़रवरी, जनवरी, जून, मार्च, मई] 
लिंक्डलिस्ट (तुलनित्र का उपयोग करके सॉर्ट किया गया): [अप्रैल, फ़रवरी, जनवरी, जून, मार्च, मई]
  
 डुप्लिकेट निकालें
 डुप्लिकेट को निकालने के लिए, आपको प्रत्येक नोड को ट्रैस करना होगा और अगले नोड के साथ तुलना करना होगा। यदि दोनों नोड्स समान हैं तो हम एक नोड को छोड़ देते हैं और अगले पर जाते हैं।
 इस तरीके से, प्रत्येक नोड को ट्रेस करने और डुप्लिकेट नोड्स से छुटकारा पाने के बाद, हम परिणामी सूची प्राप्त करेंगे जो बिना किसी डुप्लिकेट तत्वों के है।
  नीचे दिए गए डुप्लिकेट को निकालने के लिए एक जावा प्रोग्राम है। 
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(); } }  आउटपुट: 
 मूल लिंक्डलिस्ट: 
1 1 2 3 5 2 1 1 
डुप्लिकेट हटाने के बाद लिंक्डलिस्ट: 
1 2 3 5
  
 उपरोक्त कार्यक्रम में, हमारे पास डुप्लिकेट को निकालने के लिए एक लिंक की गई सूची वर्ग है। हमारे पास प्रत्येक नोड को परिभाषित करने के लिए एक वर्ग भी है। दूसरे शब्दों में, सूची में नोड इस वर्ग नोड की वस्तुएं हैं। हमारे पास नोड को एक लिंक की गई सूची में जोड़ने की विधि है।
 फिर हटाने की विधि में, हम सिर से शुरू होने वाली लिंक सूची में प्रत्येक नोड के माध्यम से आगे बढ़ते हैं और डुप्लिकेट के लिए प्रत्येक बाद के नोड की तुलना करते हैं। यदि कोई डुप्लिकेट पाया जाता है, तो हम उस नोड को छोड़ देते हैं और अगले नोड पर आगे बढ़ते हैं।
 इस तरह से ist को डुप्लिकेट नोड्स को स्किप करके बनाया जाता है और प्रिंट () विधि का उपयोग करके परिवर्तित सूची को प्रिंट किया जाता है।
 जावा में परिपत्र लिंक्ड सूची
 एक गोलाकार लिंक्ड सूची एक सूची है जिसकी पूंछ या अंतिम नोड वापस सिर या पहले नोड से जुड़ा हुआ है।
  नीचे दिए गए चित्र जावा में सर्कुलर लिंक्ड सूची को दर्शाते हैं। 
  
 जैसा कि ऊपर चित्र में दिखाया गया है, लिंक की गई सूची के अंतिम नोड या पूंछ का पता भाग शून्य पर सेट नहीं है। इसके बजाय, यह सूची के पहले नोड या प्रमुख पर वापस इंगित करता है और इस प्रकार एक परिपत्र लिंक्ड सूची बनाता है।
  नीचे दिया गया प्रोग्राम एक सर्कुलर लिंक्ड लिस्ट को लागू करता है, जिसमें हमें लिंक्ड लिस्ट के अलग-अलग नोड्स में हेरफेर करना होता है। 
 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(); } }  आउटपुट: 
 परिपत्र से जुड़ी सूची नोड्स: 
१० २० ३० ४०
  
 जावा 8 लिंक्डलिस्ट
 हालाँकि Java 8 में LinkedList वर्ग में विशेष रूप से कोई और सुविधाएँ नहीं जोड़ी गई हैं, फिर भी इसने डेटा में हेरफेर करने के लिए धाराएँ पेश कीं।
  नीचे दिए गए कार्यक्रम लिंक्डलिस्ट को प्रदर्शित करने के लिए जावा 8 स्ट्रीम का उपयोग दिखाता है। 
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); } } आउटपुट: 
 लिंक्डलिस्ट की सामग्री: 
जाल 
हरा भरा 
नीला 
सियान 
मैजेंटा
  
 बार बार पूछे जाने वाले प्रश्न
  Q # 1) जावा में लिंक्ड लिस्ट का इस्तेमाल कब किया जाता है? 
  उत्तर: चूँकि यह संशोधन कार्यों में ArrayList जैसे संग्रहों की तुलना में तेज़ है, इसलिए इसे उन अनुप्रयोगों में उपयोग किया जाना चाहिए जिनके लिए लगातार परिवर्धन / विलोपन संचालन की आवश्यकता होती है। उन अनुप्रयोगों के लिए जिनमें ज्यादातर केवल-पढ़ने के लिए डेटा है, ArrayList या इसी तरह के संग्रह का उपयोग किया जा सकता है।
  क्यू # 2)  ListNode क्या है? 
  उत्तर: एक ListNode जावा में एक लिंक्ड सूची से जुड़ा एक बुनियादी वर्ग है और एक तत्व या नोड से जुड़ी जानकारी का प्रतिनिधित्व करता है। प्रत्येक ListNode में डेटा और एक पॉइंटर या अगले तत्व का संदर्भ होता है।
  क्यू # 3)  क्या लिंक्ड सूची शून्य मानों की अनुमति देती है? 
  उत्तर: हां, लिंक की गई सूची किसी भी शून्य मान की अनुमति देती है।
  क्यू # 4)  लिंक्ड लिस्ट के क्या फायदे हैं? 
  उत्तर: कुछ फायदे हैं: 
  जोड़-तोड़ जैसे ऑपरेशन, डिलीट करना इसमें तेज है।
 किसी लिंक की गई सूची के लिए मेमोरी को प्री-आवंटित करने की आवश्यकता नहीं है और इस प्रकार यह कुशल मेमोरी उपयोग में परिणत होता है।
 यह मेमोरी के लिए अतिरिक्त पहुंच के बिना तेजी से पहुंच का समय प्रदान करता है, और इसे निरंतर समय में विस्तारित किया जा सकता है।
 यह एक गतिशील डेटा संरचना है
 जोड़े या हटाए गए मूल्यों के आधार पर रन टाइम पर बढ़ता और सिकुड़ता है।
 
  क्यू # 5)  लिंक की गई सूची का आवेदन क्या है? 
  उत्तर: इसका उपयोग अधिकतर निम्नलिखित अनुप्रयोगों में किया जाता है: 
  MS-Word, Photoshop, आदि जैसे सॉफ्टवेयर में Word पूर्ववत ’कार्यक्षमता को लागू करने के लिए।
 स्टैक और कतार जैसी डेटा संरचनाओं को लागू करने के लिए।
 हम लिंक की गई सूची का उपयोग करके ग्राफ़ भी लागू कर सकते हैं।
 बाल्टी हैशिंग के लिए, प्रत्येक बाल्टी को एक लिंक्ड सूची के रूप में लागू किया जा सकता है।
 
  क्यू # 6)  लिंक्ड लिस्ट की सीमाएं क्या हैं? 
  उत्तर: कुछ सीमाएँ हैं: 
  प्रत्येक नोड में अगले तत्व के संदर्भ को रखने के लिए एक अतिरिक्त पॉइंटर के साथ, उपयोग की गई मेमोरी सरणियों से बहुत अधिक है।
 यह कड़ाई से अनुक्रमिक रूप से एक्सेस की गई डेटा संरचना है इसलिए लिंक की गई सूची के नोड्स को हमेशा शुरुआत से पढ़ा जाना चाहिए।
 खासकर पिछड़ी हुई सूचियों को पीछे छोड़ना मुश्किल है।
 चूंकि नोड्स को गैर-सन्निहित स्थानों में संग्रहीत किया जाता है, इसलिए एक्सेस के लिए आवश्यक समय अधिक हो सकता है।
 
 निष्कर्ष
 इस ट्यूटोरियल में हमने बुनियादी लिंक्ड लिस्ट डेटा संरचना सीखी है। फिर हम जावा में प्रदान किए गए java.util.LinkedList वर्ग पर चले गए। हमने इस वर्ग पर विस्तार से चर्चा की जिसमें इसके निर्माता, विधियाँ आदि शामिल हैं।
 हमने लिंक्ड सूचियों से संबंधित कुछ विशेष परिचालनों पर भी चर्चा की है जैसे छँटाई, सूची को उलटना, डुप्लिकेट को हटाना, परिपत्र से जुड़ी सूची आदि।
   हमारे अगले ट्यूटोरियल में, हम दोगुनी लिंक्ड सूची की विशिष्ट विशेषताओं पर चर्चा करेंगे।  
उदाहरण के साथ ब्लैक बॉक्स परीक्षण क्या है
  => पूर्ण जावा प्रशिक्षण गाइड यहाँ देखें।  
  अनुशंसित पाठ
    जावा में संदिग्ध लिंक की गई सूची - कार्यान्वयन और कोड उदाहरण  
  जावा सूची - जावा में सूची कैसे बनाएं, आरंभ करें और उपयोग करें  
  Java List Methods - Sort List, Contains, List Add, List Remove  
  जावा में द्विआधारी खोज एल्गोरिथम - कार्यान्वयन और उदाहरण  
  सम्मिलन सॉर्ट जावा में - प्रविष्टि सॉर्ट एल्गोरिथ्म और उदाहरण  
  उदाहरण के साथ जावा इंटरफेस और एब्सट्रैक्ट क्लास ट्यूटोरियल  
  सी + + में चित्र संरचना के साथ लिंक्ड सूची डेटा संरचना  
  जावा में गुप्त और अन्य संग्रह करने के लिए गुप्त सूची