# What Is Queue Data Structure in JavaScript?

//

Larry Thompson

A queue is a linear data structure that follows the First-In-First-Out (FIFO) principle. In other words, the element that is inserted first is the first one to be removed.

## Implementation of Queue in JavaScript

In JavaScript, we can implement a queue using an array or a linked list. Let’s explore both of these methods.

### Using an Array

To create a queue using an array, we can use various built-in methods such as push() to add elements to the end of the queue and shift() to remove elements from the front of the queue.

Example:

``````
// Initialize an empty queue
let queue = [];

// Enqueue elements
queue.push(1);
queue.push(2);
queue.push(3);

// Dequeue element
let frontElement = queue.shift();
console.log(frontElement); // Output: 1
```
```

This code snippet demonstrates how we can use an array as a queue. The `push()` method adds elements to the end of the array, and the `shift()` method removes and returns the first element from the front.

An alternative way to implement a queue in JavaScript is by using a linked list. A linked list consists of nodes where each node contains data and a reference to the next node. We maintain two pointers: one points to the front of the queue, called head, and another points to the rear, called tail.

``````
// Define Node class
class Node {
constructor(data) {
this.data = data;
this.next = null;
}
}

// Define Queue class
class Queue {
constructor() {
this.tail = null;
}

enqueue(data) {
let newNode = new Node(data);

this.tail = newNode;
} else {
this.tail.next = newNode;
this.tail = newNode;
}
}

dequeue() {
return null;
}

this.tail = null;
}

return frontElement;
}
}

// Create a new queue
let queue = new Queue();

// Enqueue elements
queue.enqueue(1);
queue.enqueue(2);
queue.enqueue(3);

// Dequeue element
let frontElement = queue.dequeue();
console.log(frontElement); // Output: 1
```
```

This code snippet demonstrates how we can implement a queue using a linked list. The `enqueue()` method adds elements to the rear of the queue by creating a new node and updating the tail pointer. The `dequeue()` method removes and returns the element from the front by updating the head pointer.

## Use Cases of Queue Data Structure

The queue data structure is widely used in various scenarios, such as:

• Scheduling tasks: Queues are often used in task scheduling algorithms where tasks are executed in a specific order.
• Breadth-First Search (BFS): BFS algorithm uses a queue to traverse a graph or tree level by level.
• Printer spooler: In operating systems, a queue is used to manage print jobs.
• Waiting lines: Queues are used to model waiting lines in real-life scenarios such as waiting for a bus or standing in line at a store.

## Conclusion

A queue is a fundamental data structure that allows efficient insertion and removal of elements following the FIFO principle. In JavaScript, we can implement a queue using an array or a linked list, depending on the specific requirements of the application. By understanding the concepts and use cases of queues, you can enhance your ability to design efficient and scalable JavaScript applications.