Efficient Way To Implement Priority Queue In Javascript

If you're a JavaScript developer looking to level up your coding skills and optimize your data structures, you might be interested in learning about implementing a priority queue efficiently in JavaScript. A priority queue allows you to store elements based on their priority, ensuring that the highest priority elements are served first. Let's dive into how you can achieve this in JavaScript!

To implement a priority queue in JavaScript, you can leverage the built-in data structures like arrays and objects. One of the most efficient ways is to use a min-heap data structure, which ensures the element with the highest priority is always at the root, making it easy to retrieve and remove.

To get started, you can create a PriorityQueue class that will handle the operations of inserting elements based on priority and extracting the element with the highest priority. Here's an outline of how you can implement this:

class PriorityQueue {
  constructor() {
    this.heap = [];
  }

  enqueue(value, priority) {
    const element = { value, priority };
    this.heap.push(element);
    this.bubbleUp();
  }

  dequeue() {
    const minPriorityElement = this.heap[0];
    const lastElement = this.heap.pop();
    if (this.heap.length > 0) {
      this.heap[0] = lastElement;
      this.heapifyDown();
    }
    return minPriorityElement;
  }

  bubbleUp() {
    let currentIndex = this.heap.length - 1;
    while (currentIndex > 0) {
      const parentIndex = Math.floor((currentIndex - 1) / 2);
      if (this.heap[parentIndex].priority > this.heap[currentIndex].priority) {
        [this.heap[parentIndex], this.heap[currentIndex]] = [this.heap[currentIndex], this.heap[parentIndex]];
        currentIndex = parentIndex;
      } else {
        break;
      }
    }
  }

  heapifyDown() {
    let currentIndex = 0;
    while (true) {
      let leftChildIndex = 2 * currentIndex + 1;
      let rightChildIndex = 2 * currentIndex + 2;
      let smallest = currentIndex;

      if (leftChildIndex < this.heap.length && this.heap[leftChildIndex].priority < this.heap[smallest].priority) {
        smallest = leftChildIndex;
      }

      if (rightChildIndex < this.heap.length && this.heap[rightChildIndex].priority < this.heap[smallest].priority) {
        smallest = rightChildIndex;
      }

      if (smallest !== currentIndex) {
        [this.heap[currentIndex], this.heap[smallest]] = [this.heap[smallest], this.heap[currentIndex]];
        currentIndex = smallest;
      } else {
        break;
      }
    }
  }
}

In this implementation, the enqueue method adds an element to the priority queue while maintaining the heap property by calling the bubbleUp function. The dequeue method removes and returns the element with the highest priority while ensuring the structure remains a valid min-heap through the heapifyDown process.

By using this PriorityQueue class and the min-heap data structure, you can efficiently implement a priority queue in JavaScript to handle elements based on their priority levels. This can be particularly useful in scenarios where you need to process tasks in order of significance or urgency.

Remember, understanding and implementing data structures like priority queues can enhance your problem-solving skills and help you write more efficient and optimized code in your JavaScript projects. So, go ahead, give it a try, and level up your coding game!