feat: Queue VIP

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section 25 Collections Frameworks/Queue Interface/src/Images/Queue Working.png

@@ -1,10 +1,12 @@
 Queue Interface in Java
------------------------
 
 Definition:
+
 The Queue interface is part of the java.util package and is a child interface of the Collection interface.
-It represents a collection designed for **holding elements prior to processing**, typically following the
-**FIFO (First-In, First-Out)** principle.
+
+It represents a collection designed for holding elements prior to processing, typically following the
+FIFO (First-In, First-Out) principle.
+
 However, some implementations (like PriorityQueue or Deque) provide different ordering policies.
 
 Key Features of Queue Interface:

Section 25 Collections Frameworks/Queue Interface/src/VIP/Key Features of Queue Interface.txt

@@ -1,8 +1,8 @@
 Queue Interface in Java
------------------------
 
 Definition:
 The Queue interface is part of the java.util package and is a child interface of the Collection interface.
+
 It represents a **First-In, First-Out (FIFO)** data structure, though some implementations may differ (like PriorityQueue).
 A Queue models the concept of a **waiting line**, where elements are processed in the order they arrive.
 

Section 25 Collections Frameworks/Queue Interface/src/VIP/Queue Interface In Java.txt

@@ -1,13 +1,15 @@
 Queue — Theory, Internal Working:
 
 Overview
---------
+
 - `Queue` is an interface (java.util.Queue) modeling FIFO (first-in-first-out) behavior.
-- Multiple implementations exist: `LinkedList` (unbounded, non-blocking), `ArrayBlockingQueue` (bounded, blocking), `PriorityQueue` (not FIFO — ordered by comparator), `ConcurrentLinkedQueue`, etc.
-- Key difference: a `Queue` is a semantic contract (enqueue/dequeue), while `LinkedList` is a concrete data structure that can implement a queue.
+- Multiple implementations exist: `LinkedList` (unbounded, non-blocking), `ArrayBlockingQueue` (bounded, blocking),
+`PriorityQueue` (not FIFO — ordered by comparator), `ConcurrentLinkedQueue`, etc.
+
+- Key difference: a `Queue` is a semantic contract (enqueue/dequeue), while `LinkedList` is a concrete
+data structure that can implement a queue.
 
 Core queue methods and semantics
--------------------------------
 - `add(e)`: inserts element; throws exception if capacity restricted and full.
 - `offer(e)`: inserts element; returns `false` if capacity restricted and full.
 - `remove()`: removes and returns head; throws exception if empty.
@@ -16,19 +18,17 @@ Core queue methods and semantics
 - `peek()`: returns head without removing; returns `null` if empty.
 
 Queue internal variants and their internals
-------------------------------------------
-1. **LinkedList as Queue**
+1. LinkedList as Queue
    - Internally a doubly-linked list (see previous box).
    - `add`/`offer` at tail = O(1); `remove`/`poll` at head = O(1).
    - Unbounded (limited by memory).
 
-   ASCII:
-
-   Enqueue 1: [1]
-   Enqueue 2: [1, 2]
-   Dequeue(): 1 removed -> [2]
+ASCII:
+Enqueue 1: [1]
+Enqueue 2: [1, 2]
+Dequeue(): 1 removed -> [2]
 
-2. **ArrayBlockingQueue**
+2. ArrayBlockingQueue
 - Fixed-size circular buffer (array) with head/tail indices.
 - For multi-thread usage, supports blocking operations (`put`, `take`) with locks/conditions.
 - `offer` vs `add` semantics differ only when full.
@@ -44,19 +44,18 @@ array: [10, _, _, _, _] head=0 tail=1
 
 take(): val = array[head]; head=(head+1)%5; size–
 
-3. **ConcurrentLinkedQueue**
+3. ConcurrentLinkedQueue
 - Lock-free, linked-node based queue using CAS (compare-and-swap).
 - High-concurrency non-blocking implementation suitable for many threads.
 - Iterators are weakly consistent (may or may not reflect concurrent updates).
 
 Key differences between Queue implementations
----------------------------------------------
-- **Threading & Blocking**
+- Threading & Blocking
 - `LinkedList`: not thread-safe (unless externally synchronized).
 - `ArrayBlockingQueue`: thread-safe, supports blocking operations (`put/take`).
 - `ConcurrentLinkedQueue`: thread-safe, non-blocking.
 
-- **Capacity**
+- Capacity
 - `LinkedList`: unbounded.
 - `ArrayBlockingQueue`: bounded (fixed capacity).
 - `ConcurrentLinkedQueue`: effectively unbounded.
@@ -77,7 +76,6 @@ public class LinkedListAsQueue {
      System.out.println("Peek: " + q.peek()); // 2 (without removing)
  }
 }
-```
 
 Example code: ArrayBlockingQueue (bounded, thread-safe)
 
@@ -98,18 +96,17 @@ public class BoundedQueueExample {
         }
     }
 }
-```
 
 When to use which queue
-	•	Use LinkedList/ArrayDeque for simple single-threaded FIFO needs.
-	•	Use ArrayBlockingQueue or LinkedBlockingQueue for producer-consumer bounded/unbounded blocking queues.
-	•	Use ConcurrentLinkedQueue for high-concurrency non-blocking queues.
-	•	Use PriorityQueue when you need priority ordering rather than FIFO.
+•	Use LinkedList/ArrayDeque for simple single-threaded FIFO needs.
+•	Use ArrayBlockingQueue or LinkedBlockingQueue for producer-consumer bounded/unbounded blocking queues.
+•	Use ConcurrentLinkedQueue for high-concurrency non-blocking queues.
+•	Use PriorityQueue when you need priority ordering rather than FIFO.
 
 Performance summary
-	•	Enqueue/dequeue in LinkedList and ArrayDeque: O(1).
-	•	ArrayBlockingQueue: O(1) but may block threads.
-	•	ConcurrentLinkedQueue: expected O(1) amortized, highly concurrent.
+•	Enqueue/dequeue in LinkedList and ArrayDeque: O(1).
+•	ArrayBlockingQueue: O(1) but may block threads.
+•	ConcurrentLinkedQueue: expected O(1) amortized, highly concurrent.
 
 ASCII example overview
 

Section 25 Collections Frameworks/Queue Interface/src/VIP/Queue — Theory, Internal Working.txt

@@ -1,18 +1,17 @@
-Quick Differences: LinkedList vs Queue (Concept)
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Quick Differences: LinkedList vs Queue
 
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 | Aspect              | LinkedList (Concrete Class)                        | Queue (Interface / Concept)                                                                                                       |
 |---------------------|----------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------|
-| **Type**            | Concrete data structure (implements List, Deque)   | Abstract contract that defines FIFO behavior                                                                                      |
-| **Hierarchy**       | Extends `AbstractSequentialList`, implements `List`, `Deque`, `Queue` | Belongs to `java.util`, implemented by `LinkedList`, `PriorityQueue`, `ArrayDeque`, `ArrayBlockingQueue`, etc. |
-| **Primary Purpose** | General-purpose doubly-linked list (list + deque)  | First-In-First-Out (FIFO) semantics (enqueue/dequeue)                                                                             |
-| **Data Structure**  | Doubly-linked nodes (each node has `prev`, `next`) | Depends on implementation: linked list, array, skip list, heap                                                                    |
-| **Ordering**        | Maintains insertion order                         | FIFO ordering (or priority-based for `PriorityQueue`)                                                                              |
-| **Random Access**   | Supported via index (`get(int)`), but O(n)         | Not always supported; depends on implementation                                                                                   |
-| **Insert/Remove**   | Fast at head/tail (`addFirst`, `removeLast`)       | `offer()` adds to tail, `poll()`/`remove()` removes from head                                                                     |
-| **Null Handling**   | Allows multiple nulls                              | Depends: `LinkedList` allows nulls, but `PriorityQueue` / concurrent queues may disallow                                          |
-| **Thread-Safety**   | Not thread-safe (must synchronize externally)      | Varies: `ArrayBlockingQueue`, `ConcurrentLinkedQueue` are thread-safe                                                             |
-| **Iteration**       | Bidirectional (`ListIterator`)                     | Depends on implementation; usually forward-only FIFO                                                                              |
-| **Use Cases**       | When you need both **list-like** (random access) and **deque-like** behavior | When you need pure queue semantics (task scheduling, producer-consumer, buffering)                      |
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+| Type                | Concrete data structure (implements List, Deque)   | Abstract contract that defines FIFO behavior                                                                                      |
+| Hierarchy           | Extends `AbstractSequentialList`, implements `List`, `Deque`, `Queue` | Belongs to `java.util`, implemented by `LinkedList`, `PriorityQueue`, `ArrayDeque`, `ArrayBlockingQueue`, etc. |
+| Primary Purpose     | General-purpose doubly-linked list (list + deque)  | First-In-First-Out (FIFO) semantics (enqueue/dequeue)                                                                             |
+| Data Structure      | Doubly-linked nodes (each node has `prev`, `next`) | Depends on implementation: linked list, array, skip list, heap                                                                    |
+| Ordering            | Maintains insertion order                         | FIFO ordering (or priority-based for `PriorityQueue`)                                                                              |
+| Random Access       | Supported via index (`get(int)`), but O(n)         | Not always supported; depends on implementation                                                                                   |
+| Insert/Remove       | Fast at head/tail (`addFirst`, `removeLast`)       | `offer()` adds to tail, `poll()`/`remove()` removes from head                                                                     |
+| Null Handling       | Allows multiple nulls                              | Depends: `LinkedList` allows nulls, but `PriorityQueue` / concurrent queues may disallow                                          |
+| Thread-Safety       | Not thread-safe (must synchronize externally)      | Varies: `ArrayBlockingQueue`, `ConcurrentLinkedQueue` are thread-safe                                                             |
+| Iteration           | Bidirectional (`ListIterator`)                     | Depends on implementation; usually forward-only FIFO                                                                              |
+| Use Cases           | When you need both **list-like** (random access) and **deque-like** behavior | When you need pure queue semantics (task scheduling, producer-consumer, buffering)                      |
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Section 25 Collections Frameworks/Queue Interface/src/VIP/Quick Differences LinkedList vs Queue.txt

@@ -31,7 +31,7 @@ Key Features of Queue:
    - `ConcurrentLinkedQueue`, `ArrayBlockingQueue`, `PriorityBlockingQueue` provide thread-safe operations.
 
 Queue Interface Hierarchy (Simplified)
---------------------------------------
+
 Queue (interface)
 │
 ├── Deque (interface)  → Double-ended queue, supports insertion/removal from both ends
@@ -47,8 +47,8 @@ Queue (interface)
     ├── PriorityBlockingQueue → Priority-based ordering with blocking
     └── DelayQueue / SynchronousQueue etc. for advanced use-cases
 
+
 ASCII Conceptual View (FIFO Queue)
-----------------------------------
 
 Offer/Enqueue → [10] → [20] → [30] → [40] → [50] → ...
                 ↑head                        ↑tail
@@ -58,27 +58,24 @@ Poll/Dequeue removes from head:
   new head = 20
 
 Special Case (PriorityQueue)
-----------------------------
+
 Internally uses a binary heap:
    [5, 10, 15, 20]
    Root (5) is always the minimum (or maximum, depending on comparator).
    poll() removes the root, heap is restructured.
 
 When to Use Queue
------------------
 - When you need FIFO ordering (task scheduling, buffer management).
 - When you want priority-based processing (PriorityQueue).
 - In concurrent applications (producer-consumer) → use BlockingQueue variants.
 
 Practical Examples
-------------------
 1. Printer spooler: tasks queued in order of arrival.
 2. OS job scheduling: processes waiting in FIFO or priority order.
 3. Producer-consumer design: producers put items in a queue, consumers take items from it.
 4. Real-time systems: DelayQueue, SynchronousQueue, etc. for advanced coordination.
 
 Complexity
-----------
 - offer/add: O(1) in linked or array-backed queues.
 - poll/remove: O(1) in FIFO queues; O(log n) in PriorityQueue (heap-based).
 - peek/element: O(1).