S09L09 - जावा संग्रह ढांचे में लिंक्डलिस्ट

html


लिंक्ड लिस्ट में महारत: शुरुआती और डेवलपर्स के लिए एक व्यापक मार्गदर्शिका
सामग्री तालिका

परिचय ................................................................. 3
लिंक्ड लिस्ट को समझना ................................... 5

लिंक्ड लिस्ट क्या है? ..................................... 5
लिंक्ड लिस्ट के घटक ....................... 7


लिंक्ड लिस्ट बनाम अन्य डेटा संरचनाएँ .......... 10

लिंक्ड लिस्ट बनाम एरे .................................. 10
लिंक्ड लिस्ट बनाम स्टैक .................................... 12
लिंक्ड लिस्ट बनाम वेक्टर ................................ 14


लिंक्ड लिस्ट पर ऑपरेशंस .................................... 16

नोड जोड़ना ........................................................ 16
नोड हटाना ..................................................... 18
नोड संशोधित करना .................................................. 20


Java में लिंक्ड लिस्ट को लागू करना .................. 22

नोड क्लास संरचना ......................................... 22
LinkedList क्लास संरचना ............................. 24
सैंपल कोड: लिंक्ड लिस्ट बनाना ............ 26


निष्कर्ष ................................................................. 30
अतिरिक्त संसाधन ............................................. 32


परिचय
"मास्टरींग लिंक्ड लिस्ट्स: शुरुआती और डेवलपर्स के लिए एक व्यापक मार्गदर्शिका।" में आपका स्वागत है। यह eBook कंप्यूटर विज्ञान की मौलिक डेटा संरचनाओं में से एक, लिंक्ड लिस्ट्स की जटिलताओं में गहराई से जाता है। चाहे आप बुनियादी बातों को समझने के लिए एक शुरुआती हों या अपनी समझ को परिष्कृत करने के लिए एक डेवलपर हों, यह मार्गदर्शिका लिंक्ड लिस्ट्स और अन्य डेटा संरचनाओं के साथ उनकी तुलना के बारे में स्पष्ट, संक्षिप्त और संरचित अंतर्दृष्टि प्रदान करती है।
लिंक्ड लिस्ट्स का महत्व
लिंक्ड लिस्ट्स विभिन्न अनुप्रयोगों में महत्वपूर्ण हैं, जैसे डायनेमिक मेमोरी अलोकेशन लागू करना से लेकर स्टैक्स और क्यूज़ जैसी जटिल डेटा संरचनाओं का निर्माण करना। कुछ ऑपरेशंस में उनकी लचीलापन और दक्षता उन्हें डेवलपर्स के लिए अनिवार्य उपकरण बनाती है।
इस eBook का उद्देश्य
यह मार्गदर्शिका लिंक्ड लिस्ट्स की संरचना, ऑपरेशंस, और कार्यान्वयन को कवर करते हुए उनकी गहन समझ प्रदान करने का लक्ष्य रखती है। इसके अलावा, यह लिंक्ड लिस्ट्स की तुलना अन्य डेटा संरचनाओं जैसे एरेज़, स्टैक्स, और वेक्टर के साथ करती है, उनके संबंधित लाभों और उपयोग के मामलों को उजागर करती है।
लिंक्ड लिस्ट्स के फायदे और नुकसान


फायदे
नुकसान


डायनेमिक साइज
पॉइंटर्स के लिए अतिरिक्त मेमोरी


कुशल इन्सर्ट्स/डिलीशंस
कोई रैंडम एक्सेस नहीं


मेमोरी अलोकेशन में लचीलापन
बढ़ा हुआ ओवरहेड


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

लिंक्ड लिस्ट्स को समझना
लिंक्ड लिस्ट क्या है?
एक linked list एक रैखिक डेटा संरचना है जहाँ प्रत्येक तत्व, जिसे नोड कहा जाता है, दो भागों में विभाजित होता है:

डेटा: संग्रहित मूल्य या जानकारी।
एड्रेस (Next Pointer): अनुक्रम में अगले नोड का संदर्भ।

एरेज़ की तरह, लिंक्ड लिस्ट्स को कंटिगस मेमोरी अलोकेशन की आवश्यकता नहीं होती, जिससे डायनेमिक डेटा को प्रबंधित करने में अधिक लचीलापन मिलता है।
लिंक्ड लिस्ट के घटक
Node
एक नोड लिंक्ड लिस्ट का मौलिक घटक है। प्रत्येक नोड में डेटा और अगले नोड की ओर एक पॉइंटर होता है, जो एक श्रृंखला जैसा ढांचा बनाता है।
Head
लिंक्ड लिस्ट में पहला नोड को head के रूप में जाना जाता है। यह लिस्ट में प्रवेश बिंदु के रूप में कार्य करता है।
Null Pointer

फायदे	नुकसान
डायनेमिक साइज	पॉइंटर्स के लिए अतिरिक्त मेमोरी
कुशल इन्सर्ट्स/डिलीशंस	कोई रैंडम एक्सेस नहीं
मेमोरी अलोकेशन में लचीलापन	बढ़ा हुआ ओवरहेड

अंतिम नोड का next पॉइंटर null की ओर संकेत करता है, जो लिस्ट के अंत को दर्शाता है।


लिंक्ड लिस्ट का आरेख

चित्र 1: लिंक्ड लिस्ट की संरचना
लिंक्ड लिस्ट कैसे काम करती है
लिंक्ड लिस्ट को इंटरकनेक्टेड नोड्स की एक श्रृंखला के रूप में कल्पना करें:


Head Node: डेटा और दूसरे नोड की ओर पॉइंटर शामिल है।
Intermediate Nodes: प्रत्येक में डेटा और अगले नोड की ओर पॉइंटर होता है।

Last Node: डेटा और एक null पॉइंटर शामिल है, जो अंत का संकेत देता है।


यह संरचना कुशल इन्सर्शन और डिलीशन ऑपरेशंस की अनुमति देती है, बस पॉइंटर्स को अपडेट करके बिना पूरे डेटा संरचना को पुनर्गठित किए।

लिंक्ड लिस्ट बनाम अन्य डेटा संरचनाएँ
समझना कि लिंक्ड लिस्ट्स अन्य डेटा संरचनाओं की तुलना में कैसे हैं, आपके अनुप्रयोग के लिए सही चुनने के लिए महत्वपूर्ण है।
लिंक्ड लिस्ट बनाम एरे


विशेषता
Linked List
Array


साइज
डायनेमिक
फिक्स्ड साइज


मेमोरी उपयोग
पॉइंटर्स के लिए अतिरिक्त मेमोरी
प्रभावी मेमोरी उपयोग


इन्सर्शन/डिलीशन
कुशल (O(1) अगर नोड ज्ञात हो)
अक्षम (O(n))


एक्सेस समय
सीक्वेंशियल एक्सेस (O(n))
रैंडम एक्सेस (O(1))


लचीलापन
अतिसंवेदनशील
कम लचीला


मुख्य निष्कर्ष: लिंक्ड लिस्ट्स डायनेमिक साइजिंग और कुशल इन्सर्शन/डिलीशन प्रदान करती हैं, जबकि एरेज़ तेज एक्सेस टाइम और बेहतर मेमोरी दक्षता प्रदान करते हैं।
लिंक्ड लिस्ट बनाम स्टैक


विशेषता
Linked List
Stack


उद्देश्य
जनरल-पर्पस डेटा संरचना
LIFO (Last-In-First-Out) व्यवहार


ऑपरेशंस
इन्सर्शन, डिलीशन कहीं भी
Push और pop ऑपरेशंस


लचीलापन
अतिसंवेदनशील
स्टैक ऑपरेशंस तक सीमित


मुख्य निष्कर्ष: जबकि स्टैक्स विशेष रूप से LIFO ऑपरेशंस के लिए हैं, लिंक्ड लिस्ट्स विभिन्न ऑपरेशंस के लिए अधिक लचीलापन प्रदान करती हैं।
लिंक्ड लिस्ट बनाम वेक्टर


विशेषता
Linked List
Vector


डायनेमिक साइज
हां
हां


रैंडम एक्सेस
नहीं
हां


इन्सर्शन/डिलीशन
बीच के ऑपरेशंस में कुशल
आखिर में कुशल


मेमोरी अलोकेशन
नॉन-कंटिगस
कंटिगस


मुख्य निष्कर्ष: वेक्टर रैंडम एक्सेस और कुशल अंत ऑपरेशंस प्रदान करते हैं, जबकि लिंक्ड लिस्ट्स बीच के इन्सर्शन और डिलीशंस में उत्कृष्ट हैं।

लिंक्ड लिस्ट पर ऑपरेशंस
लिंक्ड लिस्ट्स पर ऑपरेशंस में महारत हासिल करना प्रभावी कार्यान्वयन और हैंडलिंग के लिए आवश्यक है।
नोड जोड़ना
लिंक्ड लिस्ट में एक नोड जोड़ने के विभिन्न तरीके हो सकते हैं:

शुरुआत में:

एक नया नोड बनाएं।
इसके next पॉइंटर को वर्तमान head पर सेट करें।
head को नए नोड पर अपडेट करें।


अंत में:

अंतिम नोड तक जाएं।
अंतिम नोड के next पॉइंटर को नए नोड पर सेट करें।


दी गई नोड के बाद:

निर्दिष्ट नोड पर नेविगेट करें।
नए नोड के next पॉइंटर को निर्दिष्ट नोड के next पर सेट करें।
निर्दिष्ट नोड के next पॉइंटर को नए नोड पर अपडेट करें।



उदाहरण कोड:




		
		
			
			
Java
			
			public void addAtBeginning(int data) {
    Node newNode = new Node(data);
    newNode.next = head;
    head = newNode;
}
			
				
					
				
					1
2
3
4
5
				
						public void addAtBeginning(int data) {
    Node newNode = new Node(data);
    newNode.next = head;
    head = newNode;
}
					
				
			
		


नोड हटाना
नोड हटाने में शामिल है:

नोड की पहचान करना:

हटाने के लिए नोड खोजने के लिए लिस्ट को ट्रैवर्स करें।


पॉइंटर्स को अपडेट करना:

पिछले नोड के next पॉइंटर को हटाए जाने वाले नोड के बाद वाले नोड पर सेट करें।


किनारे के मामलों को संभालना:

यदि head को हटाया जा रहा है, तो head को अगले नोड पर अपडेट करें।
यदि नोड नहीं मिला, तो अनुसार हैंडल करें।



उदाहरण कोड:




		
		
			
			
Java
			
			public void deleteNode(int key) {
    Node temp = head, prev = null;

    if (temp != null && temp.data == key) {
        head = temp.next;
        return;
    }

    while (temp != null && temp.data != key) {
        prev = temp;
        temp = temp.next;
    }

    if (temp == null) return;

    prev.next = temp.next;
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
				
						public void deleteNode(int key) {
    Node temp = head, prev = null;
 
    if (temp != null && temp.data == key) {
        head = temp.next;
        return;
    }
 
    while (temp != null && temp.data != key) {
        prev = temp;
        temp = temp.next;
    }
 
    if (temp == null) return;
 
    prev.next = temp.next;
}
					
				
			
		


नोड संशोधित करना
नोड के डेटा को संशोधित करने में शामिल है:

ट्रैवर्सल:

उस नोड पर नेविगेट करें जिसे संशोधित करने की आवश्यकता है।


डेटा को अपडेट करना:

नोड के डेटा फ़ील्ड को बदलें।



उदाहरण कोड:




		
		
			
			
Java
			
			public void modifyNode(int oldData, int newData) {
    Node current = head;
    while (current != null) {
        if (current.data == oldData) {
            current.data = newData;
            return;
        }
        current = current.next;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						public void modifyNode(int oldData, int newData) {
    Node current = head;
    while (current != null) {
        if (current.data == oldData) {
            current.data = newData;
            return;
        }
        current = current.next;
    }
}
					
				
			
		



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




		
		
			
			
Java
			
			public class Node {
    int data;
    Node next;

    public Node(int data) {
        this.data = data;
        this.next = null;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						public class Node {
    int data;
    Node next;
 
    public Node(int data) {
        this.data = data;
        this.next = null;
    }
}
					
				
			
		


LinkedList क्लास संरचना
LinkedList क्लास नोड्स का प्रबंधन करती है और लिस्ट को मैनिपुलेट करने के लिए मेथड्स प्रदान करती है।




		
		
			
			
Java
			
			public class LinkedList {
    Node head;

    public LinkedList() {
        head = null;
    }

    // Method to add a node at the beginning
    public void addAtBeginning(int data) {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }

    // Method to delete a node
    public void deleteNode(int key) {
        Node temp = head, prev = null;

        if (temp != null && temp.data == key) {
            head = temp.next;
            return;
        }

        while (temp != null && temp.data != key) {
            prev = temp;
            temp = temp.next;
        }

        if (temp == null) return;

        prev.next = temp.next;
    }

    // Method to modify a node
    public void modifyNode(int oldData, int newData) {
        Node current = head;
        while (current != null) {
            if (current.data == oldData) {
                current.data = newData;
                return;
            }
            current = current.next;
        }
    }

    // Method to display the linked list
    public void display() {
        Node current = head;
        while (current != null) {
            System.out.print(current.data + " -> ");
            current = current.next;
        }
        System.out.println("null");
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
				
						public class LinkedList {
    Node head;
 
    public LinkedList() {
        head = null;
    }
 
    // Method to add a node at the beginning
    public void addAtBeginning(int data) {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }
 
    // Method to delete a node
    public void deleteNode(int key) {
        Node temp = head, prev = null;
 
        if (temp != null && temp.data == key) {
            head = temp.next;
            return;
        }
 
        while (temp != null && temp.data != key) {
            prev = temp;
            temp = temp.next;
        }
 
        if (temp == null) return;
 
        prev.next = temp.next;
    }
 
    // Method to modify a node
    public void modifyNode(int oldData, int newData) {
        Node current = head;
        while (current != null) {
            if (current.data == oldData) {
                current.data = newData;
                return;
            }
            current = current.next;
        }
    }
 
    // Method to display the linked list
    public void display() {
        Node current = head;
        while (current != null) {
            System.out.print(current.data + " -> ");
            current = current.next;
        }
        System.out.println("null");
    }
}
					
				
			
		


सैंपल कोड: लिंक्ड लिस्ट बनाना
यहां बताया गया है कि आप उपरोक्त क्लास का उपयोग करके लिंक्ड लिस्ट कैसे बना सकते हैं और मैनिपुलेट कर सकते हैं:




		
		
			
			
Java
			
			public class Main {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();

        // Adding nodes
        list.addAtBeginning(3);
        list.addAtBeginning(2);
        list.addAtBeginning(1);
        System.out.print("Linked List after adding nodes: ");
        list.display(); // Output: 1 -> 2 -> 3 -> null

        // Deleting a node
        list.deleteNode(2);
        System.out.print("Linked List after deleting node 2: ");
        list.display(); // Output: 1 -> 3 -> null

        // Modifying a node
        list.modifyNode(3, 4);
        System.out.print("Linked List after modifying node 3 to 4: ");
        list.display(); // Output: 1 -> 4 -> null
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
				
						public class Main {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
 
        // Adding nodes
        list.addAtBeginning(3);
        list.addAtBeginning(2);
        list.addAtBeginning(1);
        System.out.print("Linked List after adding nodes: ");
        list.display(); // Output: 1 -> 2 -> 3 -> null
 
        // Deleting a node
        list.deleteNode(2);
        System.out.print("Linked List after deleting node 2: ");
        list.display(); // Output: 1 -> 3 -> null
 
        // Modifying a node
        list.modifyNode(3, 4);
        System.out.print("Linked List after modifying node 3 to 4: ");
        list.display(); // Output: 1 -> 4 -> null
    }
}
					
				
			
		


कोड का विवरण:

नोड्स जोड़ना:

डेटा 3, 2, और 1 के साथ नोड्स को शुरुआत में जोड़ा जाता है, जिससे लिस्ट 1 -> 2 -> 3 -> null बनती है।


नोड हटाना:

डेटा 2 वाला नोड हटाया जाता है, जिससे लिस्ट 1 -> 3 -> null में अपडेट होती है।


नोड संशोधित करना:

डेटा 3 वाले नोड को 4 में संशोधित किया जाता है, जिससे 1 -> 4 -> null प्राप्त होता है।




निष्कर्ष
लिंक्ड लिस्ट्स शक्तिशाली और लचीली डेटा संरचनाएँ हैं जो विभिन्न संगणकीय कार्यों के लिए आवश्यक हैं। उनकी डायनेमिक प्रकृति कुशल मेमोरी उपयोग और इन्सर्शन तथा डिलीशन ऑपरेशंस को सरल बनाती है। लिंक्ड लिस्ट्स को समझना न केवल आपके मौलिक कंप्यूटर विज्ञान अवधारणाओं को बेहतर बनाता है बल्कि आपको अधिक जटिल डेटा संरचनाओं को आसानी से लागू करने और हैंडल करने के कौशल से लैस करता है।
मुख्य निष्कर्ष:

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

लिंक्ड लिस्ट्स की बहुमुखी प्रतिभा को अपनाएं ताकि आप अधिक कुशल और स्केलेबल अनुप्रयोगों का निर्माण कर सकें।
SEO Keywords: Linked list, data structures, nodes, Java linked list implementation, dynamic memory allocation, linked list vs array, linked list vs stack, linked list operations, adding nodes, deleting nodes, modifying nodes, programming data structures, beginner data structures, developer guide.

अतिरिक्त संसाधन

Oracle Java Documentation
GeeksforGeeks - Linked List
Wikipedia - Linked List
Java Tutorials by Oracle
Stack Overflow - Linked List Discussions


Note: This article is AI generated.

विशेषता	Linked List	Array
साइज	डायनेमिक	फिक्स्ड साइज
मेमोरी उपयोग	पॉइंटर्स के लिए अतिरिक्त मेमोरी	प्रभावी मेमोरी उपयोग
इन्सर्शन/डिलीशन	कुशल (O(1) अगर नोड ज्ञात हो)	अक्षम (O(n))
एक्सेस समय	सीक्वेंशियल एक्सेस (O(n))	रैंडम एक्सेस (O(1))
लचीलापन	अतिसंवेदनशील	कम लचीला

विशेषता	Linked List	Stack
उद्देश्य	जनरल-पर्पस डेटा संरचना	LIFO (Last-In-First-Out) व्यवहार
ऑपरेशंस	इन्सर्शन, डिलीशन कहीं भी	Push और pop ऑपरेशंस
लचीलापन	अतिसंवेदनशील	स्टैक ऑपरेशंस तक सीमित

विशेषता	Linked List	Vector
डायनेमिक साइज	हां	हां
रैंडम एक्सेस	नहीं	हां
इन्सर्शन/डिलीशन	बीच के ऑपरेशंस में कुशल	आखिर में कुशल
मेमोरी अलोकेशन	नॉन-कंटिगस	कंटिगस