Java Academy · पाठ

LinkedList की आंतरिक संरचना

LinkedList की doubly-linked node structure और उसकी time-complexity profile का अध्ययन करें।

पाठ 1, कुल 4 में से13 चरण

LinkedList की आंतरिक संरचना, CoddyKit पर Java Academy का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Java Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Java Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

LinkedList की आंतरिक संरचना

Java की LinkedList एक द्वि-संयोजित सूची है: प्रत्येक Node में पिछले और अगले Node का संदर्भ तथा तत्व का मान होता है। ArrayList के विपरीत, इसमें कोई आधारभूत सारणी नहीं होती — प्रत्येक Node के लिए अलग से मेमोरी आवंटित की जाती है।

class Node<T> {
    T data;
    Node<T> prev;
    Node<T> next;
    Node(T data) { this.data = data; }
}

समय जटिलता की रूपरेखा

LinkedList की प्रदर्शन विशेषताएँ ArrayList से काफी अलग हैं:

addFirst / addLast: O(1)
get(index): O(n) — head या tail से traversal करना पड़ता है
remove(index): खोजने में O(n), फिर unlink करने में O(1)
Iterator traversal: O(n)

जब आपको head/tail पर बार-बार प्रविष्टियाँ करनी हों, तब LinkedList का उपयोग करें; यादृच्छिक पहुँच के लिए नहीं।

LinkedList बनाना और उसमें traversal करना

LinkedList बनाना और उसमें पुनरावृत्ति करना उसी List interface का अनुसरण करता है जिसे आप पहले से जानते हैं। अंतर केवल आंतरिक संरचना का है।

import java.util.LinkedList;

LinkedList<String> list = new LinkedList<>();
list.add("Alice");
list.add("Bob");
list.add("Carol");

for (String name : list) {
    System.out.println(name);
}

System.out.println("First: " + list.getFirst()); // Alice
System.out.println("Last: "  + list.getLast());  // Carol

addFirst, addLast, removeFirst, removeLast

LinkedList head/tail संचालन उपलब्ध कराता है जिन्हें ArrayList कुशलता से उपलब्ध नहीं कराता:

LinkedList<Integer> nums = new LinkedList<>();
nums.addLast(10);   // [10]
nums.addLast(20);   // [10, 20]
nums.addFirst(5);   // [5, 10, 20]

System.out.println(nums.removeFirst()); // 5  → [10, 20]
System.out.println(nums.removeLast());  // 20 → [10]

Node को जोड़ने वाला संबंध हटाना: खोजने के बाद O(1) में हटाना

एक बार iterator के माध्यम से किसी Node का संदर्भ मिल जाए, तो हटाना O(1) होता है, क्योंकि केवल next/prev संकेतकों को अपडेट करना पड़ता है — ArrayList की तरह तत्वों को खिसकाना नहीं पड़ता।

import java.util.*;

LinkedList<String> tasks = new LinkedList<>(List.of("A","B","C","D"));
Iterator<String> it = tasks.iterator();
while (it.hasNext()) {
    String t = it.next();
    if (t.equals("B") || t.equals("D")) {
        it.remove(); // O(1) unlink
    }
}
System.out.println(tasks); // [A, C]

ArrayList की तुलना में मेमोरी का अतिरिक्त उपयोग

प्रत्येक LinkedList Node में दो अतिरिक्त संदर्भ (prev, next) और तत्व का संदर्भ होता है — 64-बिट JVM पर प्रत्येक प्रविष्टि के लिए लगभग 48 बाइट। ArrayList सन्निहित सारणी में केवल तत्व का संदर्भ (8 बाइट) रखता है।

बड़े और अधिक-पठन वाले डेटा-समुच्चयों के लिए ArrayList आम तौर पर कैश के लिए अधिक अनुकूल होता है और कम मेमोरी उपयोग करता है।

डबल-एंड कतार संचालन: स्टैक और कतार

LinkedList, Deque interface को लागू करता है, इसलिए इसे स्टैक और कतार दोनों की तरह उपयोग किया जा सकता है।

import java.util.LinkedList;
import java.util.Deque;

// As a Queue (FIFO)
Deque<String> queue = new LinkedList<>();
queue.offer("first");
queue.offer("second");
System.out.println(queue.poll()); // first

// As a Stack (LIFO)
Deque<String> stack = new LinkedList<>();
stack.push("bottom");
stack.push("top");
System.out.println(stack.pop()); // top

PriorityQueue का परिचय

PriorityQueue हीप-आधारित कतार है, जिसमें natural order या तुलनाकर्ता के अनुसार सबसे छोटा तत्व हमेशा पहले कतार से निकाला जाता है। यह NOT linked list पर आधारित है — इसके लिए बाइनरी हीप वाली सारणी का उपयोग होता है।

import java.util.PriorityQueue;

PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.offer(40);
pq.offer(10);
pq.offer(25);

System.out.println(pq.poll()); // 10 (smallest)
System.out.println(pq.poll()); // 25
System.out.println(pq.poll()); // 40

अपनी तुलनाकर्ता के साथ PriorityQueue

क्रम उलटने या किसी विशेष फ़ील्ड के अनुसार sort करने के लिए Comparator दें:

import java.util.*;

record Task(String name, int priority) {}

PriorityQueue<Task> tasks = new PriorityQueue<>(
    Comparator.comparingInt(Task::priority).reversed() // highest first
);
tasks.offer(new Task("Low", 1));
tasks.offer(new Task("High", 10));
tasks.offer(new Task("Med", 5));

while (!tasks.isEmpty()) {
    System.out.println(tasks.poll().name());
}
// High, Med, Low

LinkedList और ArrayList में से चुनना

सामान्य नियम:

यादृच्छिक पहुँच, पुनरावृत्ति और अधिकांश परिस्थितियों के लिए ArrayList का उपयोग करें।
जब दोनों सिरों पर बार-बार O(1) में प्रविष्टि/हटाना हो और इंडेक्स से पहुँच की आवश्यकता न हो, तब LinkedList का उपयोग करें।
जब आपको क्रमबद्ध प्रसंस्करण चाहिए, तब PriorityQueue का उपयोग करें, जैसे कार्य निर्धारण या डायक्स्ट्रा एल्गोरिदम में।

सामान्य समस्याएँ

LinkedList पर लूप में get(i) कॉल करने से बचें — कुल जटिलता O(n²) हो जाती है:

LinkedList<Integer> list = new LinkedList<>();
for (int i = 0; i < 10000; i++) list.add(i);

// BAD: O(n^2) — each get(i) traverses from head
for (int i = 0; i < list.size(); i++) {
    int val = list.get(i); // slow!
}

// GOOD: O(n) — use iterator
for (int val : list) {
    // process val
}

त्वरित जाँच

LinkedList का कौन-सा संचालन सूची के आकार से स्वतंत्र रूप से O(1) होता है?

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन: LinkedList और डबल-एंड कतार

मुख्य बातें:

LinkedList एक द्वि-संयोजित सूची है, जिसमें head/tail संचालन O(1) होते हैं
यादृच्छिक पहुँच (इंडेक्स के आधार पर प्राप्ति/स्थापन) O(n) होती है
यह Deque को लागू करता है — इसे स्टैक या कतार की तरह उपयोग किया जा सकता है
PriorityQueue हीप के क्रम में प्रसंस्करण उपलब्ध कराता है
अधिकांश उपयोगों के लिए ArrayList को प्राथमिकता दें; head/tail में बार-बार बदलाव के लिए LinkedList बेहतर है

शुरुआत निःशुल्क

एआई शिक्षक के साथ Java सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 104
पाठ: 374

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “LinkedList की आंतरिक संरचना” पाठ निःशुल्क है?

हाँ—“LinkedList की आंतरिक संरचना” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Java Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Java Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“LinkedList की आंतरिक संरचना” में मैं क्या सीखूँगा?

LinkedList की doubly-linked node structure और उसकी time-complexity profile का अध्ययन करें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Java Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Java Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Java Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।

“LinkedList की आंतरिक संरचना” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Java Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Java Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← Java Academy पर वापस जाएँ