# What Is the Implementation of Queue Data Structure?

//

Heather Bennett

A queue is a linear data structure that follows the First-In-First-Out (FIFO) principle. It can be implemented in various programming languages to efficiently manage and process data. In this article, we will explore the implementation of a queue data structure and understand its key operations.

## The Queue Data Structure

A queue is like a real-life queue, where people stand in line and are served in the order they arrived. Similarly, in a queue data structure, elements are added at one end called the “rear” or “tail,” and removed from the other end called the “front” or “head.” This ensures that elements are processed in the same order they were added.

Let’s dive into the implementation details of a queue using HTML:

### Queue Implementation Using Arrays

In many programming languages, arrays can be used as a simple way to implement a queue. Here’s a basic example of implementing a queue using arrays:

```<script>
// Define an empty array to store the elements
let queue = [];

// Add an element to the rear of the queue
function enqueue(element) {
queue.push(element);
}

// Remove an element from the front of the queue
function dequeue() {
if (!isEmpty()) {
return queue.shift();
}
return null;
}

// Check if the queue is empty
function isEmpty() {
return (queue.length === 0);
}

// Get the front element without removing it
function peek() {
if (!isEmpty()) {
return queue[0];
}
return null;
}
</script>
```

This implementation uses an array and provides four basic operations: enqueue, dequeue, isEmpty, and peek. The enqueue operation adds an element to the rear of the queue using the `push()` method.

The dequeue operation removes the front element from the queue using the `shift()` method. The isEmpty function checks if the queue is empty by comparing its length to zero. Finally, the peek function allows us to get the front element without removing it.

### Queue Implementation Using Linked List

An alternative way to implement a queue is by using a linked list. In this approach, each element in the queue is represented by a node that contains both data and a reference to the next node.

```<script>
// Define a class for creating nodes
class Node {
constructor(data) {
this.data = data;
this.next = null;
}
}

// Define a class for implementing a queue
class Queue {
constructor() {
this.front = null;
this.rear = null;
}

// Add an element to the rear of the queue
enqueue(element) {
const newNode = new Node(element);

if (this.isEmpty()) {
this.front = newNode;
this.rear = newNode;
} else {
this.rear.next = newNode;
this.rear = newNode;
}
}

// Remove an element from the front of the queue
dequeue() {
if (!this.isEmpty()) {
const removedNode = this.front;

if (this.front === this.rear) {
// Only one node in the list
this.front = null;
this.rear = null;
} else {
this.front = removedNode.next;
}

return removedNode.data;
}

return null;
}

// Check if the queue is empty
isEmpty() {
return (this.front === null);
}

// Get the front element without removing it
peek() {
if (!this.isEmpty()) {
return this.front.data;
}
return null;
}
}
</script>
```

In this implementation, we define a Node class to create individual nodes with data and next references. The Queue class has two pointers, front and rear, which point to the first and last nodes of the queue, respectively.

The enqueue operation adds a new node to the rear of the queue by updating the next reference of the current rear node. The dequeue operation removes the front node from the queue and updates the front pointer accordingly. The isEmpty function checks if both front and rear are null to indicate an empty queue.

## Conclusion

In conclusion, a queue is an essential data structure that follows FIFO order. It can be implemented using arrays or linked lists in various programming languages. Implementing a queue allows for efficient management and processing of data in applications where order matters.

By understanding how to implement a queue and its operations, you can leverage this powerful data structure in your own projects. So go ahead and experiment with queues to enhance your coding skills!