# Double Your Data Structures with Deque: An Introduction

## Deque: A Brief Introduction

Have you ever heard of a Deque? At first glance, it might sound like an obscure computer science term that you’d never use, but in reality, it’s a fundamental data structure that you’ll encounter frequently, as its an essential ingredient in algorithm design.

In this article, we’ll introduce you to the concept of a Deque, explore its properties and operations, and compare it with another popular data structure, the Queue.

### What is a Deque?

The term “Deque” is an abbreviation for “double-ended queue,” which is precisely what it is – a collection of elements that supports insertion and deletion from both ends. In other words, it is like a stack and a queue combined.

It’s a more flexible data structure than either of its components because it allows efficient adding or removing operations from the front and rear of the deque. Thus, it offers several useful features such as:

• Constant time insertion and removal of elements from both ends
• Efficient iteration over the deque elements
• Easy removal of the first and last elements

## Comparison with Queue

A Queue is another data structure that keeps elements in order, but unlike the Deque, it restricts the insertion and deletion at the ends. It follows the First In First Out (FIFO) protocol and has operations to Enqueue (add an element to the back-end) and Dequeue (remove the element from the front-end) elements.

The critical difference is that a Deque allows for insertion and deletion from front-end or back-end, while the Queue restricts its operations only to the back-end for Enqueue and front-end for Dequeue.

## Example of Creating and Operating on a Deque

Let’s dive into an example of initializing and operating on a Deque.

### Creating a Deque

Deque is a standard library collection in many programming languages, including Python. We can easily create a Deque in Python, as shown below:

``````from collections import deque
# Creating an empty deque
d = deque()
# Adding elements to the right in deque
d.append(1)
d.append(2)
d.append(3)
# Adding elements to the left in deque
d.appendleft(0)
# Printing all the elements in deque
print(d)
``````

### Output:

``````deque([0, 1, 2, 3])
``````

### Appending and Popping from the End

Use the `append()` method to add an element to the end of the deque and `pop()` to remove the last element. The pop method returns the last element and removes it from the deque.

``````d.append(4)  # appending at the end of deque
print(d.pop())  # popping last element
``````

### Output:

``````4
``````

### Appending and Popping from the Front

To add an element to the front of the deque, use the `appendleft()` method, and to remove the first element, use the `popleft()` method.

``````d.appendleft(-1)
print(d.popleft())
``````

### Output:

``````-1
``````

## Conclusion

In conclusion, a Deque is a universally usable data structure that can substitute for both stack and queue data structures. It allows for both insertion and deletion of elements from both ends.

This versatile structure can make several algorithmic tasks more manageable and can improve program performance.

## How to Peek in Front of a Deque Without Popping?

Let’s start by clarifying that “peeking” is the action of looking at an element in a data structure without removing it, unlike a pop operation that removes the element from the structure. In this section, we’ll discuss two ways to peek at the front of a deque without popping any elements.

### Using Indexing

We can access the first element in a deque directly using indexing because a deque supports random access to its elements. Since a deque allows both left and right operations, it’s essential to note that we only want to access the first element using indexing.

Here’s a demonstration:

``````from collections import deque
d = deque([1, 2, 3])
print(d[0])  # outputs 1
``````

In the above example, `d[0]` is the first element of the deque, and we printed it using the print statement. You can incorporate this method in an algorithm that requires to check the first few elements of a deque.

### Using Iter and Next

We can also access the first element of a deque using the `iter` and `next` functions. The `iter` function returns an iterator, and we can use the `next` function to get the first element from the iterator without removing it.

Here’s an example:

``````from collections import deque
d = deque([1, 2, 3])
dq_iterator = iter(d)
print(next(dq_iterator))  # outputs 1
``````

In the above example, we created an iterator `dq_iterator` from the deque using the `iter` function. We passed the iterator to the `next` function to get the first element from it, which is the same as the first position element in the deque.

Note: One disadvantage of using this method is that we have to create an iterator first, which might not be useful for small inputs. However, it’s useful when combined with looping operations, like `for` statements.

## Conclusion

In summary, a deque is a double-ended queue that supports adding or removing elements from both ends. It’s an essential data structure for building algorithms that need to efficiently handle multiple operations, such as real-time systems, operating systems scheduling, etc.

The purpose of this article is to introduce the deque concept to readers who are unfamiliar with it and provide insights on its properties, operations, and differences with the Queue structure. Finally, we have discussed two ways to peek at the front of a deque without popping any elements, using indexing and iter and next functions.

Using these methods depends on the algorithmic contexts, and we suggest familiarizing yourself with both approaches.

In conclusion, the article has provided an introduction to the deque, a double-ended queue that supports insertion and deletion at both ends.

It has also compared it with a Queue and demonstrated how to create, initialize, and operate a Deque. Furthermore, we’ve discussed two methods to peek at the front of a deque without popping elements.

Deque is a fundamental data structure that plays a crucial role in the design of efficient algorithms for various real-world problems. Therefore, understanding the deque operation and properties is essential for programmers and computer scientists alike.