feat: Double-Ended Queue

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

Author: Someshdiwan

Section 25 Collections Frameworks/Queue Interface/Deque/src/Deque.txt

@@ -1,25 +1,30 @@
-Overview
 The Deque<E> interface (short for Double-Ended Queue, pronounced "deck") extends Queue<E> and SequencedCollection<E>.
+
 It represents a linear collection that allows insertion and removal of elements from both ends.
 
 Most implementations of Deque do not impose a fixed size limit, but capacity-restricted deques can be implemented as well.
 
-Operations
-This interface provides methods for insertion, removal, and examination of elements at both ends of the deque. Each operation comes in two forms:
+Operations:
+
+This interface provides methods for insertion, removal, and examination of elements at both ends of the deque.
 
+Each operation comes in two forms:
 Throws an exception if the operation fails.
 Returns a special value (null or false) if the operation fails.
 
-### **Deque<E> (java.util)**
+Deque<E> (java.util)
 
-#### **Overview**
-The `Deque<E>` interface (short for **Double-Ended Queue**, pronounced "deck") extends `Queue<E>` and `SequencedCollection<E>`. It represents a **linear collection** that allows **insertion and removal of elements from both ends**.
+Overview:
+The `Deque<E>` interface (short for **Double-Ended Queue**, pronounced "deck") extends `Queue<E>` and
+`SequencedCollection<E>`.
 
-Most implementations of `Deque` **do not impose a fixed size limit**, but capacity-restricted deques can be implemented as well.
+It represents a linear collection that allows **insertion and removal of elements from both ends.
 
----
+Most implementations of `Deque` do not impose a fixed size limit, but capacity-restricted deques can be implemented
+as well.
 
-##### Summary of Deque Methods
+
+Summary of Deque Methods:
 
 | Operation    | First Element (Head)                   | Last Element (Tail)                  |
 |--------------|----------------------------------------|--------------------------------------|
@@ -30,18 +35,17 @@ Most implementations of `Deque` **do not impose a fixed size limit**, but capaci
 | Examine      |  getFirst() (Throws exception)         | getLast() (Throws exception)         |
 |              |  peekFirst() (Returns special value)   | peekLast() (Returns special value)   |
 
----
 
-#### FIFO Behavior (Queue Mode)
+FIFO Behavior (Queue Mode)
 
 When used as a queue, Deque follows FIFO (First-In-First-Out) behavior:
 
 - Elements are added at the end (offerLast(e)).
 - Elements are removed from the front (pollFirst()).
 
-##### Comparison of Queue and Deque Methods
+Comparison of Queue and Deque Methods
 
-| Queue Method** | **Equivalent Deque Method** |
+| Queue Method   |   Equivalent Deque Method   |
 |----------------|-----------------------------|
 | add(e)         | addLast(e)                  |
 | offer(e)       | offerLast(e)                |
@@ -52,9 +56,9 @@ When used as a queue, Deque follows FIFO (First-In-First-Out) behavior:
 
 ---
 
-#### LIFO Behavior (Stack Mode)
+LIFO Behavior (Stack Mode)
 
-A Deque can also function as a LIFO (Last-In-First-Out) stack**, serving as a modern replacement for the legacy Stack class.
+A Deque can also function as a LIFO (Last-In-First-Out) stack, serving as a modern replacement for the legacy Stack class.
 - Elements are pushed to the front (addFirst(e)).
 - Elements are popped from the front (removeFirst()).
 
@@ -73,25 +77,21 @@ A Deque can also function as a LIFO (Last-In-First-Out) stack**, serving as a mo
 # Additional Functionalities
 
 - Removing Interior Elements:
-
   - removeFirstOccurrence(Object o): Removes the first occurrence of a specified element.
   - removeLastOccurrence(Object o): Removes the  last occurrence of a specified element.
-
   - No Indexed Access: Unlike List<E>, Deque<E> does not support indexed element access.
 
 - Null Elements:
-- Deque implementations are **not strictly required** to prohibit null elements.
-- However, using null is discouraged because it conflicts with methods that return null to indicate an empty deque**.
+- Deque implementations are not strictly required** to prohibit null elements.
+- However, using null is discouraged because it conflicts with methods that return null to indicate an empty deque.
 
 - Equality & Hashing:
-
 - Deque implementations do not override** equals() and hashCode().
 - Instead, they inherit identity-based implementations from Object.
 
 ---
 
-#Additional Information:
-
+# Additional Information:
 - Part of the Java Collections Framework
 - Introduced in Java 1.6
 - Designed by Doug Lea & Josh Bloch
@@ -100,7 +100,7 @@ A Deque can also function as a LIFO (Last-In-First-Out) stack**, serving as a mo
 ---
 
 Conclusion:
+The Deque<E> interface is a versatile data structure that can function as both a queue (FIFO) and a stack (LIFO).
 
-The Deque<E> interface is a versatile data structure that can function as both **a queue (FIFO) and a stack (LIFO).
 It provides efficient insertion and removal operations at both ends,
-making it well-suited for double-ended processing scenarios.
+making it well-suited for double-ended processing scenarios.