Using LinkedList as List, Queue, and Deque – Polymorphic Power
Using LinkedList as List, Queue, and Deque – Polymorphic Power
जब हम Java में LinkedList की बात करते हैं, तो ये सिर्फ एक simple data structure नहीं है — ये एक powerful polymorphic class है, जो List, Queue और Deque तीनों के रूप में काम कर सकती है। इस flexibility के कारण ही LinkedList को Java Collections Framework में इतना important माना जाता है। इस blog में हम detail में समझेंगे कि LinkedList को कैसे तीन अलग-अलग interfaces की तरह use किया जा सकता है, और ये polymorphism कैसे काम करता है।
What is LinkedList?
LinkedList Java में एक class है जो java.util package के अंदर मौजूद होती है। ये class doubly linked list structure पर based होती है, जिसका मतलब है कि हर node के पास दो references होते हैं — एक previous node का और दूसरा next node का।
LinkedList class List, Deque, और Queue interfaces को implement करती है। इसी वजह से ये multiple behaviors दिखा सकती है — यही इसका polymorphic power है।
Key Characteristics of LinkedList
- Doubly linked structure – हर node previous और next node से जुड़ा होता है।
- Dynamic size – elements जोड़ने या हटाने पर size अपने आप बदलता है।
- No capacity restriction – unlike ArrayList, इसे resize करने की जरूरत नहीं होती।
- Implements multiple interfaces –
List,Deque,Queue।
Using LinkedList as List
जब हम LinkedList को List interface के रूप में use करते हैं, तब ये sequential data store करने और access करने का काम करती है। इस case में हम elements को add, remove, और get कर सकते हैं जैसे किसी normal List में करते हैं।
Important List Operations
add(E e)– list के end में element जोड़ता है।add(int index, E element)– किसी specific position पर element insert करता है।get(int index)– किसी position से element निकालता है।remove(int index)– किसी index से element delete करता है।set(int index, E element)– किसी index पर value update करता है।
Example: LinkedList as List
import java.util.*;
class Demo {
public static void main(String[] args) {
List<String> list = new LinkedList<>();
list.add("Java");
list.add("Python");
list.add("C++");
System.out.println("List Elements: " + list);
list.remove(1);
System.out.println("After Remove: " + list);
}
}
ऊपर के example में LinkedList को List के रूप में use किया गया है। इसमें हमने add() और remove() जैसे typical List methods का use किया है।
Advantages of Using LinkedList as List
- Insertion और Deletion operations बहुत fast होते हैं।
- Dynamic structure होने के कारण memory utilization बेहतर होता है।
- Index-based access supported है (लेकिन थोड़ा slower)।
Disadvantages
- Random access slow होता है क्योंकि traversal sequential होता है।
- Memory overhead ज्यादा होता है क्योंकि हर node के साथ दो references रहते हैं।
Using LinkedList as Queue
जब हम LinkedList को Queue के रूप में use करते हैं, तो ये FIFO (First In, First Out) principle को follow करता है। Queue mainly elements को add और remove करने के लिए use की जाती है — जैसे job scheduling, data buffering, या message processing में।
Important Queue Operations
offer(E e)– Queue के end में element जोड़ता है।poll()– Queue के head से element remove करता है और return करता है।peek()– Queue के head element को return करता है लेकिन remove नहीं करता।
Example: LinkedList as Queue
import java.util.*;
class QueueExample {
public static void main(String[] args) {
Queue<Integer> queue = new LinkedList<>();
queue.offer(10);
queue.offer(20);
queue.offer(30);
System.out.println("Queue Elements: " + queue);
System.out.println("Peek: " + queue.peek());
System.out.println("Poll: " + queue.poll());
System.out.println("After Poll: " + queue);
}
}
यहाँ LinkedList को Queue के रूप में use किया गया है। हमने offer(), peek() और poll() methods का इस्तेमाल किया है। ये operations FIFO order में elements handle करते हैं।
Advantages of Using LinkedList as Queue
- FIFO behavior को perfectly implement करता है।
- Queue operations constant time (O(1)) में perform होते हैं।
- Multiple thread-safe versions (जैसे ConcurrentLinkedQueue) भी available हैं।
Disadvantages
- Queue traversal sequential होता है, random access नहीं होता।
- Memory overhead फिर भी ज्यादा रहता है।
Using LinkedList as Deque
Deque का मतलब होता है Double Ended Queue — यानी elements को both ends (head और tail) से add या remove किया जा सकता है। LinkedList Deque interface को भी implement करता है, इसलिए ये Deque operations को आसानी से handle करता है।
Important Deque Operations
addFirst(E e)– शुरुआत में element add करता है।addLast(E e)– अंत में element add करता है।removeFirst()– पहला element remove करता है।removeLast()– आखिरी element remove करता है।getFirst()– पहला element return करता है बिना remove किए।getLast()– आखिरी element return करता है बिना remove किए।
Example: LinkedList as Deque
import java.util.*;
class DequeExample {
public static void main(String[] args) {
Deque<String> deque = new LinkedList<>();
deque.addFirst("C");
deque.addLast("Java");
deque.addFirst("Python");
System.out.println("Deque Elements: " + deque);
deque.removeLast();
System.out.println("After removeLast(): " + deque);
}
}
ऊपर के example में LinkedList को Deque के रूप में use किया गया है। इसमें elements दोनों ends से add और remove किए जा सकते हैं।
Advantages of Using LinkedList as Deque
- दोनों सिरों से insertion और deletion तेज़ी से होता है।
- Deque stack और queue दोनों की तरह काम कर सकता है।
- Flexibility और efficiency दोनों बढ़ती है।
Disadvantages
- Random access धीमा होता है।
- Memory usage comparatively ज्यादा है।
Polymorphic Power of LinkedList
Polymorphism का मतलब है “many forms” यानी एक object कई रूपों में behave कर सकता है। Java में यह behavior interface और inheritance के जरिए achieve किया जाता है। LinkedList इस concept का perfect example है क्योंकि एक ही object List, Queue और Deque तीनों की तरह act कर सकता है।
Example: Demonstrating Polymorphism
import java.util.*;
class PolymorphismDemo {
public static void main(String[] args) {
LinkedList<String> linkedList = new LinkedList<>();
List<String> list = linkedList;
Queue<String> queue = linkedList;
Deque<String> deque = linkedList;
list.add("A");
queue.offer("B");
deque.addFirst("C");
System.out.println("List View: " + list);
System.out.println("Queue View: " + queue);
System.out.println("Deque View: " + deque);
}
}
ऊपर के example में एक ही LinkedList object को तीन अलग-अलग interfaces के रूप में reference किया गया है। यही है polymorphic power — एक ही object अलग-अलग roles निभा सकता है depending on context।
Performance Comparison Table
| Interface Type | Access Time | Insertion/Deletion | Order Maintained |
|---|---|---|---|
| List | Slow (O(n)) | Fast (O(1) at ends) | Yes |
| Queue | Sequential | Fast (O(1)) | FIFO |
| Deque | Sequential | Fast (O(1) both ends) | Order maintained (double-ended) |
When to Use LinkedList
- जब आपको बार-बार insertion और deletion करने हों।
- जब elements का order important हो।
- जब आपको Queue या Stack जैसा behavior चाहिए।
- जब memory flexibility ज़रूरी हो।
Real-World Applications
- Task scheduling systems – जहां FIFO behavior चाहिए।
- Undo/Redo operations – Deque behavior के लिए।
- Message queues या data buffering – Queue structure के लिए।
- Browser history या playlist management – List interface के लिए।
Key Takeaways
- LinkedList एक multi-functional data structure है जो polymorphism को perfectly represent करता है।
- ये List, Queue और Deque तीनों के रूप में काम कर सकता है।
- हर interface का अपना behavior होता है जो LinkedList handle कर सकता है।
- Insertion और Deletion operations बहुत efficient होते हैं।
- Random access comparatively slow होता है लेकिन structure flexible है।
Exam Specific Notes (Quick Revision)
- LinkedList = Doubly linked structure (हर node के पास next और previous reference)।
- Implements: List, Queue, Deque → इसलिए polymorphic nature।
- List: Sequential access, insertion/deletion efficient।
- Queue: FIFO order follow करता है।
- Deque: Both ends से insertion/deletion possible।
- Time Complexity: Insertion/Deletion O(1), Access O(n)।
- Use case: जब बार-बार modification की जरूरत हो।
- Polymorphism: एक ही object multiple roles में act कर सकता है।
