implement priority queue in javascript

Wissam answered on August 16, 2022 Popularity 10/10 Helpfulness 2/10

answer implement priority queue in javascript

related priority queue javascript

related javascript built in priority queue

implement priority queue in javascript

Comment

/*
  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(""));

Popularity 10/10 Helpfulness 2/10 Language javascript

Source: Grepper

Tags: javascript priority-queue

Link to this answer
Share Copy Link

Contributed on Aug 16 2022

Wissam

0 Answers Avg Quality 2/10

Closely Related Answers

priority queue javascript

Comment

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

Popularity 9/10 Helpfulness 4/10 Language javascript

Source: Grepper

Tags: javascript j

Link to this answer
Share Copy Link

Contributed on Dec 10 2022

unel

0 Answers Avg Quality 2/10

javascript built in priority queue

Comment

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.

Popularity 7/10 Helpfulness 2/10 Language javascript

Source: Grepper

Tags: built-in javascript javascri

Link to this answer
Share Copy Link

Contributed on Apr 10 2024

Gavin Dennett

0 Answers Avg Quality 2/10

implement priority queue in javascript

Contents

More Related Answers

implement priority queue in javascript

Closely Related Answers

priority queue javascript

javascript built in priority queue

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.