# What Is De Queue in Data Structure?

//

Heather Bennett

A deque (pronounced “deck”), short for double-ended queue, is a data structure that allows insertion and removal of elements from both ends. It can be visualized as a combination of a stack and a queue, where elements can be added or removed from either the front or the back.

## Operations on Deque:

A deque supports several operations, including:

• Insertion at Front: Adds an element to the front of the deque.
• Insertion at Rear: Adds an element to the rear of the deque.
• Deletion from Front: Removes an element from the front of the deque.
• Deletion from Rear: Removes an element from the rear of the deque.
• Accessing Front Element: Retrieves the front element without removing it.
• Accessing Rear Element: Retrieves the rear element without removing it.

A deque can be implemented using various data structures such as arrays or linked lists. The choice of implementation depends on factors like expected usage pattern, required time complexity, and available memory.

The flexibility provided by deques makes them useful in many scenarios. Some advantages of using deques include:

• Efficient Insertions and Deletions:
• A deque allows constant-time insertions and deletions at both ends. This property makes it suitable for situations where elements need to be efficiently added or removed from either end without affecting other elements.

• Implementation of Double-ended Algorithms:
• Deques can be used to implement various double-ended algorithms, such as finding the maximum or minimum element in a sliding window, where elements are continuously added and removed from both ends.

• Deque as Stack or Queue:
• A deque can serve as a stack or a queue depending on whether elements are inserted and removed from the same end or different ends. This flexibility allows for efficient implementation of various algorithms.

## Example Usage:

To better understand deques, let’s consider an example where we need to process a list of elements in a specific order. We can use a deque to efficiently add and remove elements from both ends based on our requirements.

“`python
from collections import deque

# Create an empty deque
my_deque = deque()

# Add elements to the rear
my_deque.append(10)
my_deque.append(20)

# Add elements to the front
my_deque.appendleft(5)
my_deque.appendleft(2)

# Remove element from the rear
rear_element = my_deque.pop()
print(“Removed Rear Element:”, rear_element)

# Remove element from the front
front_element = my_deque.popleft()
print(“Removed Front Element:”, front_element)

# Access front and rear elements without removing them
print(“Front Element:”, my_deque[0])
print(“Rear Element:”, my_deque[-1])
“`

In this example, we create a deque using Python’s built-in `deque` class. We then add elements to both ends using the `append` and `appendleft` methods.

We remove an element from the rear using the `pop` method and remove an element from the front using the `popleft` method. Finally, we access the front and rear elements without removing them using indexing.

### Conclusion:

A deque is a versatile data structure that allows efficient insertion and removal of elements from both ends. It combines the functionality of a stack and a queue, making it suitable for various applications. By understanding its operations and advantages, you can leverage deques to solve complex problems efficiently.