Doubly Linked List (DLL): Prev and Next Pointers, Traversal Notes in Hindi & English : डबली लिंक्ड लिस्ट (DLL): द्वि-दिशात्मक ट्रैवर्सल और नोड इंसर्शन और 20 महत्वपूर्ण MCQ प्रश्न (Rajasthan IT Exam)

Post a Comment

PGDCA, BCA, B-Tech, MCA, M-Tech, B.Sc computer science राजस्थान सूचना सहायक व कंप्यूटर शिक्षक विशेष नोट्स: इस अध्याय में हम Doubly Linked List (DLL): Prev and Next Pointers, Traversal (डबली लिंक्ड लिस्ट (DLL): द्वि-दिशात्मक ट्रैवर्सल और नोड इंसर्शन) की संपूर्ण थ्योरी, मुख्य तकनीकी बिंदु, तुलनात्मक तालिका और विगत परीक्षाओं के पैटर्न पर आधारित 20 अति-महत्वपूर्ण बहुविकल्पीय प्रश्न (MCQs) विस्तृत हिंदी व अंग्रेजी व्याख्या सहित पढ़ेंगे।

Overview: A Doubly Linked List (DLL) stores both prev and next pointers in every node, enabling bidirectional traversal and O(1) deletion of a known node without predecessor scanning. This flexibility costs one extra pointer per node in memory and requires careful multi-link updates during insertions and deletions.

अध्याय सार: डबली लिंक्ड लिस्ट (DLL) के प्रत्येक नोड में prev और next दोनों पॉइंटर्स होते हैं, जिससे आगे और पीछे दोनों दिशाओं में ट्रैवर्सल तथा ज्ञात नोड का O(1) डिलीशन संभव होता है। इसकी कीमत प्रति नोड एक अतिरिक्त पॉइंटर मेमोरी और इंसर्शन-डिलीशन के समय चार लिंक अपडेट करना है।

Doubly Linked List (DLL): Prev and Next Pointers, Traversal: Detailed Notes & Architecture (डबली लिंक्ड लिस्ट (DLL): द्वि-दिशात्मक ट्रैवर्सल और नोड इंसर्शन)

1. DLL Node Structure & Pointer Memory Overhead (DLL नोड संरचना और पॉइंटर मेमोरी ओवरहेड)

[EN] Each node in a linear Doubly Linked List contains three fields: prev (pointer to the predecessor node), data (payload), and next (pointer to the successor node). The boundary invariants are head->prev == NULL and tail->next == NULL, while an empty list maintains head == tail == NULL. Because every node carries two address fields instead of one, DLL incurs twice the pointer overhead of a Singly Linked List—16 bytes of pointers per node on 64-bit architectures (or 8 bytes on 32-bit systems) before struct alignment padding.

[HI] लीनियर डबली लिंक्ड लिस्ट के प्रत्येक नोड में तीन भाग होते हैं: prev (पिछले नोड का पता), data (मूल्य) और next (अगले नोड का पता)। इसमें head->prev हमेशा NULL और अंतिम नोड का tail->next हमेशा NULL होता है, जबकि खाली लिस्ट में head == tail == NULL रहता है। प्रत्येक नोड में दो पॉइंटर्स होने के कारण 64-बिट सिस्टम पर प्रति नोड 16 बाइट्स (और 32-बिट पर 8 बाइट्स) पॉइंटर मेमोरी खर्च होती है, जो सिंगली लिंक्ड लिस्ट से दोगुनी है।

2. Forward & Backward Bidirectional Traversal (फॉरवर्ड और बैकवर्ड द्वि-दिशात्मक ट्रैवर्सल)

[EN] Unlike a Singly Linked List that can only advance forward from head, a DLL supports symmetric traversal in both directions. Forward traversal starts at head and follows ptr = ptr->next until ptr == NULL, whereas backward traversal starts at tail (or reaches the end first) and follows ptr = ptr->prev until ptr == NULL. Both passes run in O(n) time and O(1) auxiliary space, eliminating the O(n) recursion stack otherwise needed to print an SLL in reverse.

[HI] सिंगली लिंक्ड लिस्ट केवल आगे बढ़ सकती है, लेकिन DLL दोनों दिशाओं में आसानी से ट्रैवर्स होती है। फॉरवर्ड ट्रैवर्सल head से शुरू होकर ptr = ptr->next के जरिए NULL तक चलता है, जबकि बैकवर्ड ट्रैवर्सल tail से शुरू होकर ptr = ptr->prev के जरिए NULL तक लौटता है। दोनों ट्रैवर्सल O(n) समय और O(1) अतिरिक्त स्पेस में पूरे होते हैं।

3. Insertion Mechanics & Link Ordering Discipline (नोड इंसर्शन प्रक्रिया और लिंक अपडेट क्रम)

[EN] Inserting a new node before or after a known reference node runs in O(1) time and modifies up to four pointer fields in a middle position. When inserting newNode after curr, you must first link newNode->next = curr->next and newNode->prev = curr before reassigning curr->next = newNode so the rest of the list is never orphaned. If curr->next was non-NULL, you also update curr->next->prev = newNode; if curr was tail, tail advances to newNode.

[HI] किसी ज्ञात नोड के आगे या पीछे नया नोड जोड़ना O(1) समय में होता है और बीच में इंसर्शन पर अधिकतम चार पॉइंटर्स अपडेट होते हैं। curr के बाद newNode जोड़ते समय पहले newNode->next = curr->next और newNode->prev = curr सेट करना अनिवार्य है ताकि आगे की लिस्ट का लिंक न टूटे। यदि curr->next खाली (NULL) नहीं है, तो curr->next->prev = newNode भी अपडेट किया जाता है।

4. O(1) Node Deletion, Applications & XOR Lists (O(1) नोड डिलीशन, उपयोग और XOR लिंक्ड लिस्ट)

[EN] Given a direct pointer del to a node, DLL deletes it in O(1) time by stitching del->prev->next = del->next and del->next->prev = del->prev (with NULL checks when del is head or tail), whereas an SLL needs O(n) time to find the predecessor. Real-world systems rely on DLL for LRU Cache eviction (paired with a Hash Map), browser Back/Forward history, Undo/Redo buffers, and music playlist navigation. To cut pointer RAM in half, an XOR Linked List packs prev ^ next into a single bitwise-XOR address field.

[HI] यदि डिलीट किए जाने वाले नोड का पॉइंटर del सीधे ज्ञात हो, तो DLL उसे O(1) समय में हटा देती है, जबकि SLL को पिछला नोड खोजने में O(n) समय लगता है। ब्राउज़र का Back/Forward इतिहास, टेक्स्ट एडिटर का Undo/Redo, म्यूजिक प्लेलिस्ट और LRU कैश (Hash Map के साथ) DLL के प्रमुख उपयोग हैं। मेमोरी बचाने के लिए XOR लिंक्ड लिस्ट एक ही फील्ड में prev ^ next स्टोर करती है।

Syntax, Formula & Technical Example (Doubly Linked List (DLL): Prev and Next Pointers, Traversal)

struct DNode {
    int data;
    struct DNode *prev, *next;
};
void insertAfter(struct DNode *curr, struct DNode *nw) {
    nw->next = curr->next;
    nw->prev = curr;
    if (curr->next != NULL) curr->next->prev = nw;
    curr->next = nw;
}

Doubly Linked List (DLL): Prev and Next Pointers, Traversal Quick Reference & Comparison Table

DLL Feature / OperationPointer Action & ComplexityKey Exam Detail
Boundary Invariant (head->prev)Always NULL in a linear non-circular DLLStops backward traversal cleanly at the start
Insert After Given NodeO(1) time updating up to 4 pointer linksLink nw->next before overwriting curr->next
Delete Known Node PointerO(1) time via del->prev and del->nextBeats SLL O(n) predecessor search overhead
Backward Traversal from TailO(n) time stepping ptr = ptr->prev until NULLO(1) extra space; no recursion stack needed

Doubly Linked List (DLL): Prev and Next Pointers, Traversal Top 20 Bilingual MCQs with Answers

Q1. How many fields does a standard Doubly Linked List node contain?

(एक मानक डबली लिंक्ड लिस्ट (DLL) के प्रत्येक नोड में कितने मुख्य फील्ड होते हैं?)

(A) Three (prev pointer, data, and next pointer)

(B) One (combined XOR data field)

(C) Four (head, prev, data, tail)

(D) Two (data and next pointer)

Correct Answer: (A)

[EN] Every standard DLL node stores data along with two address pointers: prev for the predecessor and next for the successor.

[HI] प्रत्येक सामान्य DLL नोड में तीन भाग होते हैं: data, पिछले नोड के लिए prev पॉइंटर और अगले नोड के लिए next पॉइंटर।

Q2. On a 64-bit machine (8-byte pointers, 4-byte int, ignoring alignment padding), how much memory does a DLL node with one int occupy vs an SLL node?

(64-बिट मशीन पर (8-बाइट पॉइंटर, 4-बाइट int, पैडिंग को छोड़कर) एक DLL नोड और SLL नोड की मेमोरी क्रमशः कितनी होगी?)

(A) 20 bytes for DLL vs 12 bytes for SLL

(B) 24 bytes for DLL vs 16 bytes for SLL

(C) 16 bytes for DLL vs 8 bytes for SLL

(D) 12 bytes for DLL vs 8 bytes for SLL

Correct Answer: (A)

[EN] A DLL node holds 4 + 8 + 8 = 20 bytes (one int plus two 8-byte pointers), while an SLL node holds 4 + 8 = 12 bytes.

[HI] DLL नोड में 4 (int) + 8 (prev) + 8 (next) = 20 बाइट्स लगते हैं, जबकि SLL नोड में 4 + 8 = 12 बाइट्स लगते हैं।

Q3. What is the time complexity to delete a node from a Doubly Linked List when a pointer to that specific node is already provided?

(यदि डबली लिंक्ड लिस्ट में डिलीट किए जाने वाले नोड का पॉइंटर पहले से दिया हो, तो डिलीशन की टाइम कॉम्प्लेक्सिटी क्या होगी?)

(A) O(1)

(B) O(log n)

(C) O(n)

(D) O(n^2)

Correct Answer: (A)

[EN] Because the node holds both del->prev and del->next directly, rewiring its neighbors takes constant O(1) time.

[HI] नोड के पास अपने पिछले (prev) और अगले (next) दोनों नोड्स के पते होते हैं, इसलिए डिलीशन O(1) समय में हो जाता है।

Q4. When inserting a new node 'nw' after an interior node 'curr' in a non-empty DLL, how many pointer fields inside nodes are modified?

(गैर-खाली DLL के मध्य में किसी नोड 'curr' के बाद नया नोड 'nw' जोड़ने पर नोड्स के कुल कितने पॉइंटर फील्ड अपडेट होते हैं?)

(A) 6 pointer fields

(B) 4 pointer fields

(C) 1 pointer field

(D) 2 pointer fields

Correct Answer: (B)

[EN] Four links update: nw->next, nw->prev, curr->next->prev, and curr->next.

[HI] मध्य में इंसर्शन पर चार लिंक बदलते हैं: nw->next, nw->prev, curr->next->prev और curr->next।

Q5. Which assignment order causes a memory/link loss bug when inserting 'nw' right after 'curr'?

('curr' के ठीक बाद 'nw' जोड़ते समय किस क्रम में कोड लिखने से आगे की लिस्ट का लिंक खो जाएगा?)

(A) Updating tail = nw after linking nw->next

(B) Executing curr->next = nw before saving curr->next into nw->next

(C) Setting nw->prev = curr before nw->next = curr->next

(D) Checking if (curr->next != NULL) before updating nw->prev

Correct Answer: (B)

[EN] Overwriting curr->next first destroys the only reference to the successor node unless saved earlier.

[HI] यदि nw->next में पुराना पता सहेजे बिना पहले ही curr->next = nw कर दिया जाए, तो आगे की लिस्ट का पता नष्ट हो जाता है।

Q6. In a linear Doubly Linked List with n > 1 nodes, what are the values of head->prev and tail->next?

(n > 1 नोड्स वाली लीनियर डबली लिंक्ड लिस्ट में head->prev और tail->next का मान क्या होता है?)

(A) head->prev is head and tail->next is NULL

(B) head->prev is tail and tail->next is head

(C) head->prev is NULL and tail->next is head

(D) Both are NULL

Correct Answer: (D)

[EN] In a non-circular DLL, there is no node before head and no node after tail, so both boundary pointers hold NULL.

[HI] गैर-सर्कुलर DLL में head से पहले और tail के बाद कोई नोड नहीं होता, इसलिए दोनों सिरे NULL रखते हैं।

Q7. What happens in insertAfter(curr, nw) if you execute curr->next->prev = nw unconditionally when curr is the last node?

(यदि curr लिस्ट का अंतिम नोड हो और बिना जांच के curr->next->prev = nw चलाया जाए, तो क्या होगा?)

(A) NULL pointer dereference (segmentation fault / crash)

(B) The list becomes circular automatically

(C) nw automatically becomes the new head

(D) Only nw->prev stays uninitialized

Correct Answer: (A)

[EN] At the tail node, curr->next is NULL, so accessing curr->next->prev attempts to dereference NULL.

[HI] अंतिम नोड पर curr->next का मान NULL होता है; उस पर ->prev एक्सेस करने से NULL पॉइंटर क्रैश (Segmentation Fault) हो जाएगा।

Q8. Which classic data structure uses a Doubly Linked List combined with a Hash Map to achieve O(1) get and put operations?

(O(1) समय में get और put ऑपरेशन पाने के लिए किस प्रसिद्ध संरचना में Hash Map के साथ डबली लिंक्ड लिस्ट का उपयोग होता है?)

(A) LRU (Least Recently Used) Cache

(B) Disjoint Set Union

(C) Trie Prefix Tree

(D) Binary Min-Heap

Correct Answer: (A)

[EN] An LRU Cache uses a Hash Map for O(1) key lookup and a DLL to move accessed items to the front and evict the tail in O(1).

[HI] LRU कैश में कुंजी खोजने के लिए Hash Map और सबसे पुराने आइटम को O(1) में हटाने या आगे लाने के लिए DLL उपयोग होती है।

Q9. What is the auxiliary space complexity of printing a Doubly Linked List of n elements in reverse order starting from tail?

(tail पॉइंटर से शुरू करके n नोड्स की DLL को उल्टे क्रम में प्रिंट करने की अतिरिक्त स्पेस कॉम्प्लेक्सिटी क्या है?)

(A) O(n log n)

(B) O(1)

(C) O(log n)

(D) O(n)

Correct Answer: (B)

[EN] Following prev pointers from tail iteratively requires only a single loop pointer variable, costing O(1) auxiliary space.

[HI] tail से prev पॉइंटर का अनुसरण करने पर केवल एक लूप वैरिएबल लगता है, अतः अतिरिक्त स्पेस O(1) रहता है।

Q10. In a single-node linear DLL where head == tail, what happens after deleting that sole node?

(एकल नोड वाली DLL (जहाँ head == tail) से उस एकमात्र नोड को हटाने के बाद क्या स्थिति बनती है?)

(A) Both head and tail must be set to NULL before freeing the node

(B) head->next points to itself

(C) Only tail becomes NULL while head keeps the freed address

(D) prev and next both point to head

Correct Answer: (A)

[EN] Deleting the only node empties the list, so both head and tail must reset to NULL to avoid dangling pointers.

[HI] एकमात्र नोड हटने पर लिस्ट खाली हो जाती है, इसलिए डैंगलिंग पॉइंटर से बचने हेतु head और tail दोनों को NULL करना पड़ता है।

Q11. How does an XOR Linked List reduce the memory overhead of a Doubly Linked List?

(XOR लिंक्ड लिस्ट डबली लिंक्ड लिस्ट की मेमोरी खपत को कैसे कम करती है?)

(A) It stores bitwise XOR of prev and next addresses in a single pointer field

(B) It omits the next pointer and keeps only head

(C) It allocates all nodes inside a static global stack

(D) It compresses integer data values using Huffman coding

Correct Answer: (A)

[EN] Storing npx = addr(prev) ^ addr(next) lets traversal recover either neighbor via XOR with the known adjacent address.

[HI] यह प्रत्येक नोड में prev और next के पतों का बिटवाइज XOR एक ही पॉइंटर फील्ड में संग्रहीत करती है।

Q12. Compared to a Singly Linked List, what is the time complexity to insert a new node BEFORE a given node pointer p (not head) in a DLL?

(SLL की तुलना में, DLL में किसी ज्ञात नोड पॉइंटर p (head नहीं) के ठीक पहले नया नोड जोड़ने की कॉम्प्लेक्सिटी क्या होती है?)

(A) O(1) in DLL vs O(n) in SLL

(B) O(n) in DLL vs O(1) in SLL

(C) O(n) in both DLL and SLL

(D) O(log n) in both DLL and SLL

Correct Answer: (A)

[EN] DLL accesses p->prev directly in O(1), whereas SLL must scan from head to locate p's predecessor.

[HI] DLL में p->prev सीधे O(1) में मिल जाता है, जबकि SLL में पिछला नोड ढूंढने के लिए head से O(n) स्कैन करना पड़ता है।

Q13. When inserting a new node at the beginning of a non-empty DLL, which update ensures the old first node points back to the new head?

(गैर-खाली DLL की शुरुआत में नया नोड जोड़ते समय पुराना पहला नोड नए head से पीछे कैसे जुड़ता है?)

(A) tail->next = newNode

(B) head->prev = newNode (executed before updating head = newNode)

(C) head->next = newNode->prev

(D) newNode->prev = head

Correct Answer: (B)

[EN] Before moving head to newNode, head->prev must be wired to newNode so reverse traversal reaches the new first element.

[HI] head को newNode पर ले जाने से पहले पुराने head->prev को newNode पर सेट करना जरूरी है।

Q14. What does a forward-then-backward check verify in a valid non-empty linear DLL of 4 nodes: A <-> B <-> C <-> D?

(4 नोड्स वाली सही लीनियर DLL (A <-> B <-> C <-> D) में पॉइंटर संगति (consistency) कैसे सत्यापित होती है?)

(A) A->prev == D and D->next == A

(B) For every node x, x->next == x->prev

(C) B->prev->prev == NULL is false

(D) For every node x with x->next != NULL, x->next->prev == x

Correct Answer: (D)

[EN] Symmetric adjacency guarantees that stepping forward then backward returns to the exact same node (x->next->prev == x).

[HI] सही DLL में प्रत्येक आंतरिक नोड के लिए x->next->prev हमेशा वापस x के बराबर होना चाहिए।

Q15. In a DLL implementation without a tail pointer, what is the time complexity of inserting a node at the very end?

(यदि DLL में tail पॉइंटर न रखा जाए, तो लिस्ट के अंत में नया नोड जोड़ने की टाइम कॉम्प्लेक्सिटी क्या होगी?)

(A) O(n^2)

(B) O(n)

(C) O(1)

(D) O(log n)

Correct Answer: (B)

[EN] Without a tail reference, finding the last node requires walking all n nodes from head via next pointers.

[HI] tail पॉइंटर न होने पर अंतिम नोड तक पहुँचने के लिए head से सभी n नोड्स से गुजरना पड़ता है, जिससे O(n) समय लगता है।

Q16. Which of the following statements is NOT true about a Doubly Linked List?

(डबली लिंक्ड लिस्ट (DLL) के संदर्भ में निम्नलिखित में से कौन सा कथन असत्य (NOT true) है?)

(A) DLL allows O(1) deletion when the node reference is known

(B) DLL supports bidirectional traversal in O(n) time

(C) Every insertion/deletion requires updating more pointers than SLL

(D) DLL always uses less memory per node than an array or Singly Linked List

Correct Answer: (D)

[EN] DLL actually uses MORE memory per element than both SLL (extra pointer) and contiguous arrays (two pointers per node).

[HI] DLL वास्तव में SLL और एरे दोनों की तुलना में प्रति तत्व अधिक मेमोरी खर्च करती है क्योंकि इसमें दो पॉइंटर्स होते हैं।

Q17. Within Doubly Linked List (DLL): Prev and Next Pointers, Traversal, which dll feature / operation directly maps to: "Always NULL in a linear non-circular DLL"?

(Doubly Linked List (DLL): Prev and Next Pointers, Traversal में कौन सा DLL Feature / Operation सीधे "Always NULL in a linear non-circular DLL" से संबंधित है?)

(A) Backward Traversal from Tail

(B) Boundary Invariant (head->prev)

(C) Insert After Given Node

(D) Delete Known Node Pointer

Correct Answer: (B)

[EN] In Doubly Linked List (DLL): Prev and Next Pointers, Traversal, 'Boundary Invariant (head->prev)' handles 'Always NULL in a linear non-circular DLL' (Stops backward traversal cleanly at the start).

[HI] Doubly Linked List (DLL): Prev and Next Pointers, Traversal में 'Boundary Invariant (head->prev)' का कार्य/विवरण 'Always NULL in a linear non-circular DLL' (Stops backward traversal cleanly at the start) है।

Q18. Which option accurately describes 'Insert After Given Node' in Doubly Linked List (DLL): Prev and Next Pointers, Traversal?

(Doubly Linked List (DLL): Prev and Next Pointers, Traversal के संदर्भ में 'Insert After Given Node' की सही विशेषता कौन सी है?)

(A) O(1) time via del->prev and del->next

(B) O(n) time stepping ptr = ptr->prev until NULL

(C) Always NULL in a linear non-circular DLL

(D) O(1) time updating up to 4 pointer links

Correct Answer: (D)

[EN] 'Insert After Given Node' provides 'O(1) time updating up to 4 pointer links' — key point: Link nw->next before overwriting curr->next.

[HI] 'Insert After Given Node' का मुख्य विवरण 'O(1) time updating up to 4 pointer links' है (Link nw->next before overwriting curr->next)।

Q19. In Doubly Linked List (DLL): Prev and Next Pointers, Traversal, identify the correct parameter for the specification: "O(1) time via del->prev and del->next".

(Doubly Linked List (DLL): Prev and Next Pointers, Traversal में "O(1) time via del->prev and del->next" विवरण किस विकल्प के लिए सही है?)

(A) Backward Traversal from Tail

(B) Boundary Invariant (head->prev)

(C) Insert After Given Node

(D) Delete Known Node Pointer

Correct Answer: (D)

[EN] 'Delete Known Node Pointer' corresponds to 'O(1) time via del->prev and del->next' (Beats SLL O(n) predecessor search overhead).

[HI] 'Delete Known Node Pointer' का संबंध 'O(1) time via del->prev and del->next' (Beats SLL O(n) predecessor search overhead) से है।

Q20. Considering Doubly Linked List (DLL): Prev and Next Pointers, Traversal, what key behavior defines 'Backward Traversal from Tail'?

(Doubly Linked List (DLL): Prev and Next Pointers, Traversal में 'Backward Traversal from Tail' की मुख्य भूमिका या मान क्या है?)

(A) O(1) time via del->prev and del->next

(B) O(1) time updating up to 4 pointer links

(C) O(n) time stepping ptr = ptr->prev until NULL

(D) Always NULL in a linear non-circular DLL

Correct Answer: (C)

[EN] 'Backward Traversal from Tail' represents 'O(n) time stepping ptr = ptr->prev until NULL' (O(1) extra space; no recursion stack needed).

[HI] 'Backward Traversal from Tail' का अर्थ/मान 'O(n) time stepping ptr = ptr->prev until NULL' है (O(1) extra space; no recursion stack needed)।

Doubly Linked List (DLL): Prev and Next Pointers, Traversal — Exam FAQs

Q1: Why does DLL allow O(1) deletion of a given node while SLL takes O(n)?

दिए गए नोड को हटाने में DLL को O(1) और SLL को O(n) समय क्यों लगता है?

[EN] To unlink node X, you must rewrite the next pointer of X's predecessor. DLL stores that predecessor address directly in X->prev, whereas SLL has no backward link and must scan from head.

[HI] नोड X को हटाने के लिए उसके पिछले नोड का next बदलना पड़ता है। DLL में पिछला नोड सीधे X->prev में मिलता है, जबकि SLL में head से खोजना पड़ता है।

Q2: Is a tail pointer mandatory in a Doubly Linked List?

क्या डबली लिंक्ड लिस्ट में tail पॉइंटर रखना अनिवार्य है?

[EN] No, it is optional, but keeping a tail pointer drops insert-at-end, delete-at-end, and reverse traversal start from O(n) to O(1).

[HI] नहीं, यह अनिवार्य नहीं है; लेकिन tail रखने से अंत में इंसर्शन, डिलीशन और रिवर्स ट्रैवर्सल शुरुआत O(1) में हो जाती है।

Q3: When should you prefer SLL over DLL?

हमें DLL की बजाय SLL को कब प्राथमिकता देनी चाहिए?

[EN] Choose SLL when memory is tightly constrained, backward traversal is never required, and operations occur primarily at the head (such as a dynamic Stack).

[HI] जब मेमोरी सीमित हो, उल्टे क्रम में ट्रैवर्सल की जरूरत न हो और ऑपरेशन मुख्यतः शुरुआती सिरे पर हों (जैसे स्टैक), तब SLL बेहतर है।

Related Posts

  • Loading related posts...

Post a Comment

Search Topic Notes & 20 MCQs (Hindi / English)