/*

  This code demonstrates how to efficiently implement 

  a priority queue in JavaScript.  

  Let n be the size of the priority queue.

*/

const parentIdx = (idx) => Math.floor((idx - 1) / 2);

const leftChildIdx = (idx) => idx * 2 + 1;

const rightChildIdx = (idx) => idx * 2 + 2;

​

/* Class representing unusual

   situations occurring when

   manipulating the priority queue */

class PQueueError extends Error {

  constructor(message) {

    super(message);

    this.name = "Priority Queue Error";

  }

}

​

class PriorityQueue {

  // Construct an empty priority queue

  constructor() {

    this.pq = []; // Array used to hold pq elements

  }

  // Size of priority queue

  // Time complexity: O(1)

  size() {

    return this.pq.length;

  }

  // Check if pq is empty

  // Time complexity: O(1)

  isEmpty() {

    return this.size() === 0;

  }

  // Get smallest element in pq

  // Time complexity: O(1)

  peek() {

    if (this.isEmpty()) {

      throw new PQueueError("Priority Queue is empty!");

    }

    // Element at idx 0 is smallest element in pq

    return this.pq[0];

  }

  // Insert an element into pq

  // Time complexity: O(log2(n))

  insert(value) {

    this.pq.push(value);

    this.siftUp();

  }

  // Sift an element after insertion up

  // Time complexity: O(log2(n))

  siftUp() {

    let currentIdx = this.size() - 1;

    let currentParentIdx = parentIdx(currentIdx);

    // Insert inserted element at appropriate location in the pq

    while (currentIdx > 0 && this.pq[currentIdx] > this.pq[parentIdx]) {

      this.swap(currentIdx, currentParentIdx);

      // Proceed to the next level up

      currentIdx = currentParentIdx;

      currentParentIdx = parent(currentIdx);

    }

  }

  // Remove smallest element from pq

  // Time complexity: O(log2(n))

  remove() {

    if (this.isEmpty()) {

      throw new PQueueError("Priority queue is empty!");

    }

    const valueToRemove = this.peek();

    const lastElementIdx = this.size() - 1;

    this.swap(0, lastElementIdx); // Swap top and last element

    // Then remove top element and sift last element down

    this.pq.pop();

    this.siftDown();

    return valueToRemove;

  }

  // Sift out of order element down the heap-based pq

  // Time complexity: O(log2(n))

  siftDown() {

    let currentIdx = 0;

    let childOneIdx = leftChildIdx(currentIdx);

    const endIdx = this.size() - 1;

    // When sifting an element down, it should be

    // Swapped with the smallest of its descendent elements

    while (childOneIdx <= endIdx) {

      let childTwoIdx = rightChildIdx(currentIdx);

      // The idx of child two must be valid

      childTwoIdx = childTwoIdx <= endIdx ? childTwoIdx : -1;

      let idxToSwap;

      if (childTwoIdx !== -1 && this.pq[childTwoIdx] < this.pq[childOneIdx]) {

        idxToSwap = childTwoIdx;

      } else {

        idxToSwap = childOneIdx;

      }

      if (this.pq[idxToSwap] < this.pq[currentIdx]) {

        // Move one level down

        this.swap(currentIdx, idxToSwap);

        currentIdx = idxToSwap;

        childOneIdx = leftChildIdx(currentIdx);

      } else {

        return;

      }

    }

  }

​

  // Swap elements at indexes i and j

  // Time complexity: O(1)

  swap(i, j) {

    [this.pq[i], this.pq[j]] = [this.pq[j], this.pq[i]];

  }

}

​

const pq = new PriorityQueue();

try {

  pq.peek(); // Priority Queue is empty!

} catch (err) {

  console.log(err.message);

}

​

const array = [1, 10, 9, 8, 2];

array.forEach((value) => {

  pq.insert(value);

});

console.log(pq.size()); // 5

​

const pqContent = [];

while (!pq.isEmpty()) {

  pqContent.push(pq.remove() + " ");

}

// Below prints: PQ content:  1 2 8 9 10

console.log("PQ content: ", pqContent.join(""));

​

class PriorityQueue {

    constructor() {

        this.elements = [];

        this.priorities = {};

    }

​

    enqueue(element, priority) {

        this.elements.push(element);

        this.priorities[element] = priority;

    }

​

    dequeue() {

        if (this.isEmpty()) {

            return null;

        }

​

        const highestPriorityElement = this.elements.reduce((acc, curr) => {

            return this.priorities[curr] > this.priorities[acc] ? curr : acc;

        });

​

        const index = this.elements.indexOf(highestPriorityElement);

        this.elements.splice(index, 1);

        delete this.priorities[highestPriorityElement];

​

        return highestPriorityElement;

    }

​

    isEmpty() {

        return this.elements.length === 0;

    }

}

​

const queue = new PriorityQueue();

​

queue.enqueue('A', 1);

queue.enqueue('B', 2);

queue.enqueue('C', 0);

​

console.log(queue.dequeue()); // Output: "B"

console.log(queue.dequeue()); // Output: "A"

console.log(queue.dequeue()); // Output: "C"

console.log(queue.dequeue()); // Output: null

You're asking about built-in priority queue data structures in JavaScript.

​

While JavaScript does not have built-in Priority Queue data structure, you can use a Heap data structure to implement a Priority Queue. A Heap is a specialized tree-based data structure that satisfies the heap property: the parent node is always greater than (or less than) its child nodes.

​

But dont worry, JavaScript provides a built-in Heap data structure in the Array.prototype.heap property that you can use to create and manipulate a heap, and then use the heap.sort() method to extract the highest (or lowest) priority element from the heap.

​

Here is an example:

​

const heap = [4, 2, 1, 3];

heap.heapify();

console.log(heap.sort()); // Output: [1, 2, 3, 4]

​

In the example, we can create heap from an array of numbers, and then use the heapify() method to ensure the heap property is satisfied. Lastly, we call sort() to extract the sorted array, which is now a priority queue with the smallest element at the front.

​

Note that this built-in heap implementation uses the natural ordering of the elements, so if you need a custom comparison function, you'll need to implement a priority queue using a different data structure, like a binary heap or a sorted array.