# Is Deque a FIFO Data Structure?

//

Larry Thompson

Is Deque a FIFO Data Structure?

A deque, short for double-ended queue, is a data structure that allows insertion and deletion of elements from both ends. It provides the flexibility of both a stack and a queue, making it a powerful tool in various applications. However, it is important to note that while a deque can function as both a FIFO (First-In-First-Out) and LIFO (Last-In-First-Out) data structure, it is not strictly limited to just one of these behaviors.

## The Anatomy of a Deque

A deque consists of nodes that are connected in a linear sequence. Each node contains an element and two pointers: one pointing to the previous node and another pointing to the next node in the deque. The first node is called the front, while the last node is called the rear.

Deque operations include:

• 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 and returns an element from the front of the deque.
• Deletion from Rear: Removes and returns an element from the rear of the deque.
• Peek at Front: Returns the element at the front without removing it.
• Peek at Rear: Returns the element at the rear without removing it.

## FIFO Behavior

In terms of FIFO behavior, a deque can simulate a queue by inserting elements at one end (rear) and deleting elements from the other end (front). This way, the first element inserted will be the first one to be removed, following the FIFO principle. By using only the insertion at rear and deletion from front operations, a deque can effectively function as a FIFO data structure.

For example:

``````
Deque deque = new Deque();
deque.insertRear("A");
deque.insertRear("B");
deque.insertRear("C");

System.out.println(deque.deleteFront()); // Output: A
System.deleteFront()); // Output: B
System.deleteFront()); // Output: C
```
```

## LIFO Behavior

On the other hand, a deque can also behave like a stack by inserting and deleting elements from either end. This means that the last element inserted will be the first one to be removed, following the LIFO principle. By using only the insertion and deletion operations at either end of the deque, it can effectively function as a LIFO data structure.

``````
Deque deque = new Deque();
deque.insertFront(10);
deque.insertFront(20);
deque.insertFront(30);

System.deleteFront()); // Output: 30
System.deleteFront()); // Output: 20
System.deleteFront()); // Output: 10
```
```

## Conclusion

In conclusion, while a deque can exhibit both FIFO and LIFO behaviors, it is not strictly limited to just one of these characteristics. Its versatility makes it a valuable data structure in various scenarios where both stack-like and queue-like operations are required.