Class BinaryHeap

Data-Structures/Heap/BinaryHeap.js:8–133

* BinaryHeap class represents a binary heap data structure that can be configured as a Min Heap or Max Heap. * * Binary heaps are binary trees that are filled level by level and from left to right inside each level. * They have the property that any parent node has a smaller (for Min Heap) or gre

 * than its children, ensuring that the root of the tree always holds the extremal value.
 */
class BinaryHeap {
  /**
   * Creates a new BinaryHeap instance.
   * @constructor
   * @param {Function} comparatorFunction - The comparator function used to determine the order of elements (e.g., minHeapComparator or maxHeapComparator).
   */
  constructor(comparatorFunction) {
    /**
     * The heap array that stores elements.
     * @member {Array}
     */
    this.heap = []

    /**
     * The comparator function used for ordering elements in the heap.
     * @member {Function}
     */
    this.comparator = comparatorFunction
  }

  /**
   * Inserts a new value into the heap.
   * @param {*} value - The value to be inserted into the heap.
   */
  insert(value) {
    this.heap.push(value)
    this.#bubbleUp(this.heap.length - 1)
  }

  /**
   * Returns the number of elements in the heap.
   * @returns {number} - The number of elements in the heap.
   */
  size() {
    return this.heap.length
  }

  /**
   * Checks if the heap is empty.
   * @returns {boolean} - True if the heap is empty, false otherwise.
   */
  empty() {
    return this.size() === 0
  }

  /**
   * Bubbles up a value from the specified index to maintain the heap property.
   * @param {number} currIdx - The index of the value to be bubbled up.
   * @private
   */
  #bubbleUp(currIdx) {
    let parentIdx = Math.floor((currIdx - 1) / 2)

    while (
      currIdx > 0 &&
      this.comparator(this.heap[currIdx], this.heap[parentIdx])
    ) {
      this.#swap(currIdx, parentIdx)