queue-typed 1.53.6 → 1.53.7

package/src/data-structures/binary-tree/bst.ts

@@ -11,6 +11,7 @@ import type {
   BSTNOptKeyOrNode,
   BSTOptions,
   BTNRep,
+  Comparable,
   Comparator,
   CP,
   DFSOrderPattern,
@@ -23,6 +24,7 @@ import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 import { Queue } from '../queue';
 import { isComparable } from '../../utils';
+import { Range } from '../../common';
 
 export class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNodeNested<K, V>> extends BinaryTreeNode<
   K,
@@ -92,6 +94,54 @@ export class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNod
  * 5. Logarithmic Operations: Ideal operations like insertion, deletion, and searching are O(log n) time-efficient.
  * 6. Balance Variability: Can become unbalanced; special types maintain balance.
  * 7. No Auto-Balancing: Standard BSTs don't automatically balance themselves.
+ * @example
+ * // Find kth smallest element
+ *     // Create a BST with some elements
+ *     const bst = new BST<number>([5, 3, 7, 1, 4, 6, 8]);
+ *     const sortedKeys = bst.dfs(node => node.key, 'IN');
+ *
+ *     // Helper function to find kth smallest
+ *     const findKthSmallest = (k: number): number | undefined => {
+ *       return sortedKeys[k - 1];
+ *     };
+ *
+ *     // Assertions
+ *     console.log(findKthSmallest(1)); // 1
+ *     console.log(findKthSmallest(3)); // 4
+ *     console.log(findKthSmallest(7)); // 8
+ * @example
+ * // Find elements in a range
+ *     const bst = new BST<number>([10, 5, 15, 3, 7, 12, 18]);
+ *     console.log(bst.search(new Range(5, 10))); // [10, 5, 7]
+ *     console.log(bst.search(new Range(4, 12))); // [10, 12, 5, 7]
+ *     console.log(bst.search(new Range(4, 12, true, false))); // [10, 5, 7]
+ *     console.log(bst.search(new Range(15, 20))); // [15, 18]
+ *     console.log(bst.search(new Range(15, 20, false))); // [18]
+ * @example
+ * // Find lowest common ancestor
+ *     const bst = new BST<number>([20, 10, 30, 5, 15, 25, 35, 3, 7, 12, 18]);
+ *
+ *     function findFirstCommon(arr1: number[], arr2: number[]): number | undefined {
+ *       for (const num of arr1) {
+ *         if (arr2.indexOf(num) !== -1) {
+ *           return num;
+ *         }
+ *       }
+ *       return undefined;
+ *     }
+ *
+ *     // LCA helper function
+ *     const findLCA = (num1: number, num2: number): number | undefined => {
+ *       const path1 = bst.getPathToRoot(num1);
+ *       const path2 = bst.getPathToRoot(num2);
+ *       // Find the first common ancestor
+ *       return findFirstCommon(path1, path2);
+ *     };
+ *
+ *     // Assertions
+ *     console.log(findLCA(3, 10)); // 7
+ *     console.log(findLCA(5, 35)); // 15
+ *     console.log(findLCA(20, 30)); // 25
  */
 export class BST<
     K = any,
@@ -115,8 +165,9 @@ export class BST<
     super([], options);
 
     if (options) {
-      const { comparator } = options;
-      if (comparator) this._comparator = comparator;
+      const { extractComparable, isReverse } = options;
+      if (typeof extractComparable === 'function') this._extractComparable = extractComparable;
+      if (isReverse !== undefined) this._isReverse = isReverse;
     }
 
     if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
@@ -132,6 +183,17 @@ export class BST<
     return this._root;
   }
 
+  protected _isReverse: boolean = false;
+
+  /**
+   * The above function is a getter method in TypeScript that returns the value of the private property
+   * `_isReverse`.
+   * @returns The `isReverse` property of the object, which is a boolean value.
+   */
+  get isReverse(): boolean {
+    return this._isReverse;
+  }
+
   /**
    * The function creates a new BSTNode with the given key and value and returns it.
    * @param {K} key - The key parameter is of type K, which represents the type of the key for the node
@@ -155,8 +217,9 @@ export class BST<
     return new BST<K, V, R, NODE, TREE>([], {
       iterationType: this.iterationType,
       isMapMode: this._isMapMode,
-      comparator: this._comparator,
+      extractComparable: this._extractComparable,
       toEntryFn: this._toEntryFn,
+      isReverse: this._isReverse,
       ...options
     }) as TREE;
   }
@@ -217,11 +280,11 @@ export class BST<
    * @param {any} key - The `key` parameter is a value that will be checked to determine if it is of
    * type `K`.
    * @returns The `override isKey(key: any): key is K` function is returning a boolean value based on
-   * the result of the `isComparable` function with the condition `this.comparator !==
+   * the result of the `isComparable` function with the condition `this._compare !==
    * this._DEFAULT_COMPARATOR`.
    */
   override isKey(key: any): key is K {
-    return isComparable(key, this.comparator !== this._DEFAULT_COMPARATOR);
+    return isComparable(key, this._extractComparable !== undefined);
   }
 
   /**
@@ -248,11 +311,11 @@ export class BST<
 
     let current = this._root;
     while (current !== undefined) {
-      if (this.comparator(current.key, newNode.key) === 0) {
+      if (this._compare(current.key, newNode.key) === 0) {
         this._replaceNode(current, newNode);
         if (this._isMapMode) this._setValue(current.key, newValue);
         return true;
-      } else if (this.comparator(current.key, newNode.key) > 0) {
+      } else if (this._compare(current.key, newNode.key) > 0) {
         if (current.left === undefined) {
           current.left = newNode;
           if (this._isMapMode) this._setValue(newNode?.key, newValue);
@@ -350,7 +413,7 @@ export class BST<
       }
 
       if (keyA !== undefined && keyA !== null && keyB !== undefined && keyB !== null) {
-        return this.comparator(keyA, keyB);
+        return this._compare(keyA, keyB);
       }
       return 0;
     });
@@ -392,64 +455,114 @@ export class BST<
     return inserted;
   }
 
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The `merge` function overrides the base class method by adding elements from another
+   * binary search tree.
+   * @param anotherTree - `anotherTree` is an instance of a Binary Search Tree (BST) with key type `K`,
+   * value type `V`, return type `R`, node type `NODE`, and tree type `TREE`.
+   */
+  override merge(anotherTree: BST<K, V, R, NODE, TREE>) {
+    this.addMany(anotherTree, [], false);
+  }
+
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(k + log n)
    *
-   * The function `getNodes` in TypeScript overrides the base class method to retrieve nodes based on a
-   * given keyNodeEntryRawOrPredicate and iteration type.
-   * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate - The `keyNodeEntryRawOrPredicate`
-   * parameter in the `getNodes` method is used to filter the nodes that will be returned. It can be a
-   * key, a node, an entry, or a custom keyNodeEntryRawOrPredicate function that determines whether a node should be
-   * included in the result.
-   * @param [onlyOne=false] - The `onlyOne` parameter in the `getNodes` method is a boolean flag that
-   * determines whether to return only the first node that matches the keyNodeEntryRawOrPredicate (`true`) or all nodes
-   * that match the keyNodeEntryRawOrPredicate (`false`). If `onlyOne` is set to `true`, the method will stop iterating
-   * and
-   * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
-   * `getNodes` method is used to specify the starting point for traversing the tree when searching for
-   * nodes that match a given keyNodeEntryRawOrPredicate. It represents the root node of the subtree where the search
-   * should begin. If not explicitly provided, the default value for `begin
-   * @param {IterationType} iterationType - The `iterationType` parameter in the `getNodes` method
-   * specifies the type of iteration to be performed when traversing the nodes of a binary tree. It can
-   * have two possible values:
-   * @returns The `getNodes` method returns an array of nodes that satisfy the given keyNodeEntryRawOrPredicate.
+   * The function `search` in TypeScript overrides the search behavior in a binary tree structure based
+   * on specified criteria.
+   * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate - The
+   * `keyNodeEntryRawOrPredicate` parameter in the `override search` method can accept one of the
+   * following types:
+   * @param [onlyOne=false] - The `onlyOne` parameter is a boolean flag that determines whether the
+   * search should stop after finding the first matching node. If `onlyOne` is set to `true`, the
+   * search will return as soon as a matching node is found. If `onlyOne` is set to `false`, the
+   * @param {C} callback - The `callback` parameter in the `override search` function is a function
+   * that will be called on each node that matches the search criteria. It is of type `C`, which
+   * extends `NodeCallback<NODE>`. The callback function should accept a node of type `NODE` as its
+   * argument and
+   * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `override search`
+   * method represents the node from which the search operation will begin. It is the starting point
+   * for searching within the tree data structure. The method ensures that the `startNode` is a valid
+   * node before proceeding with the search operation. If the `
+   * @param {IterationType} iterationType - The `iterationType` parameter in the `override search`
+   * function determines the type of iteration to be used during the search operation. It can have two
+   * possible values:
+   * @returns The `override search` method returns an array of values that match the search criteria
+   * specified by the input parameters. The method performs a search operation on a binary tree
+   * structure based on the provided key, predicate, and other options. The search results are
+   * collected in an array and returned as the output of the method.
    */
-  override getNodes(
-    keyNodeEntryRawOrPredicate: BTNRep<K, V, NODE> | R | NodePredicate<NODE>,
+  override search<C extends NodeCallback<NODE>>(
+    keyNodeEntryRawOrPredicate: BTNRep<K, V, NODE> | R | NodePredicate<NODE> | Range<K>,
     onlyOne = false,
+    callback: C = this._DEFAULT_NODE_CALLBACK as C,
     startNode: BTNRep<K, V, NODE> | R = this._root,
     iterationType: IterationType = this.iterationType
-  ): NODE[] {
+  ): ReturnType<C>[] {
     if (keyNodeEntryRawOrPredicate === undefined) return [];
     if (keyNodeEntryRawOrPredicate === null) return [];
     startNode = this.ensureNode(startNode);
     if (!startNode) return [];
-    const callback = this._ensurePredicate(keyNodeEntryRawOrPredicate);
-    const ans: NODE[] = [];
+    let predicate: NodePredicate<NODE>;
+
+    const isRange = this.isRange(keyNodeEntryRawOrPredicate);
+    // Set predicate based on parameter type
+    if (isRange) {
+      predicate = node => keyNodeEntryRawOrPredicate.isInRange(node.key, this._comparator);
+    } else {
+      predicate = this._ensurePredicate(keyNodeEntryRawOrPredicate);
+    }
+    const isToLeftByRange = (cur: NODE) => {
+      if (isRange) {
+        const range = keyNodeEntryRawOrPredicate;
+        const leftS = this.isReverse ? range.high : range.low;
+        const leftI = this.isReverse ? range.includeHigh : range.includeLow;
+        return (leftI && this._compare(cur.key, leftS) >= 0) || (!leftI && this._compare(cur.key, leftS) > 0);
+      }
+      return false;
+    };
 
+    const isToRightByRange = (cur: NODE) => {
+      if (isRange) {
+        const range = keyNodeEntryRawOrPredicate;
+        const rightS = this.isReverse ? range.low : range.high;
+        const rightI = this.isReverse ? range.includeLow : range.includeLow;
+
+        return (rightI && this._compare(cur.key, rightS) <= 0) || (!rightI && this._compare(cur.key, rightS) < 0);
+      }
+      return false;
+    };
+    const ans: ReturnType<C>[] = [];
     if (iterationType === 'RECURSIVE') {
       const dfs = (cur: NODE) => {
-        if (callback(cur)) {
-          ans.push(cur);
+        if (predicate(cur)) {
+          ans.push(callback(cur));
           if (onlyOne) return;
         }
 
         if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
-        if (!this._isPredicate(keyNodeEntryRawOrPredicate)) {
-          const benchmarkKey = this._getKey(keyNodeEntryRawOrPredicate);
+
+        if (isRange) {
+          if (this.isRealNode(cur.left) && isToLeftByRange(cur)) dfs(cur.left);
+          if (this.isRealNode(cur.right) && isToRightByRange(cur)) dfs(cur.right);
+        } else if (!this._isPredicate(keyNodeEntryRawOrPredicate)) {
+          const benchmarkKey = this._extractKey(keyNodeEntryRawOrPredicate);
           if (
             this.isRealNode(cur.left) &&
             benchmarkKey !== null &&
             benchmarkKey !== undefined &&
-            this.comparator(cur.key, benchmarkKey) > 0
+            this._compare(cur.key, benchmarkKey) > 0
           )
             dfs(cur.left);
           if (
             this.isRealNode(cur.right) &&
             benchmarkKey !== null &&
             benchmarkKey !== undefined &&
-            this.comparator(cur.key, benchmarkKey) < 0
+            this._compare(cur.key, benchmarkKey) < 0
           )
             dfs(cur.right);
         } else {
@@ -463,24 +576,27 @@ export class BST<
       const stack = [startNode];
       while (stack.length > 0) {
         const cur = stack.pop()!;
-        if (callback(cur)) {
-          ans.push(cur);
+        if (predicate(cur)) {
+          ans.push(callback(cur));
           if (onlyOne) return ans;
         }
-        if (!this._isPredicate(keyNodeEntryRawOrPredicate)) {
-          const benchmarkKey = this._getKey(keyNodeEntryRawOrPredicate);
+        if (isRange) {
+          if (this.isRealNode(cur.left) && isToLeftByRange(cur)) stack.push(cur.left);
+          if (this.isRealNode(cur.right) && isToRightByRange(cur)) stack.push(cur.right);
+        } else if (!this._isPredicate(keyNodeEntryRawOrPredicate)) {
+          const benchmarkKey = this._extractKey(keyNodeEntryRawOrPredicate);
           if (
             this.isRealNode(cur.right) &&
             benchmarkKey !== null &&
             benchmarkKey !== undefined &&
-            this.comparator(cur.key, benchmarkKey) < 0
+            this._compare(cur.key, benchmarkKey) < 0
           )
             stack.push(cur.right);
           if (
             this.isRealNode(cur.left) &&
             benchmarkKey !== null &&
             benchmarkKey !== undefined &&
-            this.comparator(cur.key, benchmarkKey) > 0
+            this._compare(cur.key, benchmarkKey) > 0
           )
             stack.push(cur.left);
         } else {
@@ -521,23 +637,6 @@ export class BST<
     return this.getNodes(keyNodeEntryRawOrPredicate, true, startNode, iterationType)[0] ?? undefined;
   }
 
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   *
-   * The function `getNodeByKey` returns a node with a specific key from a tree data structure.
-   * @param {K} key - The key parameter is the value used to search for a specific node in the tree. It
-   * is typically a unique identifier or a value that can be used to determine the position of the node
-   * in the tree structure.
-   * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter is an optional
-   * parameter that specifies the type of iteration to be used when searching for a node in the tree.
-   * It has a default value of `'ITERATIVE'`.
-   * @returns The method is returning a NODE object or undefined.
-   */
-  override getNodeByKey(key: K, iterationType: IterationType = this.iterationType): OptNode<NODE> {
-    return this.getNode(key, this._root, iterationType);
-  }
-
   /**
    * Time complexity: O(n)
    * Space complexity: O(n)
@@ -654,9 +753,9 @@ export class BST<
 
     if (iterationType === 'RECURSIVE') {
       const dfs = (cur: NODE) => {
-        const compared = this.comparator(cur.key, targetKey);
+        const compared = this._compare(cur.key, targetKey);
         if (Math.sign(compared) === lesserOrGreater) ans.push(callback(cur));
-
+        // TODO here can be optimized to O(log n)
         if (this.isRealNode(cur.left)) dfs(cur.left);
         if (this.isRealNode(cur.right)) dfs(cur.right);
       };
@@ -668,7 +767,7 @@ export class BST<
       while (queue.size > 0) {
         const cur = queue.shift();
         if (this.isRealNode(cur)) {
-          const compared = this.comparator(cur.key, targetKey);
+          const compared = this._compare(cur.key, targetKey);
           if (Math.sign(compared) === lesserOrGreater) ans.push(callback(cur));
 
           if (this.isRealNode(cur.left)) queue.push(cur.left);
@@ -786,19 +885,26 @@ export class BST<
     return balanced;
   }
 
-  protected _DEFAULT_COMPARATOR = (a: K, b: K): number => {
+  protected _comparator: Comparator<K> = (a: K, b: K): number => {
+    if (isComparable(a) && isComparable(b)) {
+      if (a > b) return 1;
+      if (a < b) return -1;
+      return 0;
+    }
+    if (this._extractComparable) {
+      if (this._extractComparable(a) > this._extractComparable(b)) return 1;
+      if (this._extractComparable(a) < this._extractComparable(b)) return -1;
+      return 0;
+    }
     if (typeof a === 'object' || typeof b === 'object') {
       throw TypeError(
-        `When comparing object types, a custom comparator must be defined in the constructor's options parameter.`
+        `When comparing object types, a custom extractComparable must be defined in the constructor's options parameter.`
       );
     }
-    if (a > b) return 1;
-    if (a < b) return -1;
+
     return 0;
   };
 
-  protected _comparator: Comparator<K> = this._DEFAULT_COMPARATOR;
-
   /**
    * The function returns the value of the _comparator property.
    * @returns The `_comparator` property is being returned.
@@ -807,6 +913,17 @@ export class BST<
     return this._comparator;
   }
 
+  protected _extractComparable?: (key: K) => Comparable;
+
+  /**
+   * This function returns the value of the `_extractComparable` property.
+   * @returns The method `extractComparable()` is being returned, which is a getter method for the
+   * `_extractComparable` property.
+   */
+  get extractComparable() {
+    return this._extractComparable;
+  }
+
   /**
    * The function sets the root of a tree-like structure and updates the parent property of the new
    * root.
@@ -818,4 +935,8 @@ export class BST<
     }
     this._root = v;
   }
+
+  protected _compare(a: K, b: K) {
+    return this._isReverse ? -this._comparator(a, b) : this._comparator(a, b);
+  }
 }

package/src/data-structures/binary-tree/rb-tree.ts

@@ -51,6 +51,10 @@ export class RedBlackTreeNode<
   }
 }
 
+/**
+ * 1. Efficient self-balancing, but not completely balanced. Compared with AVLTree, the addition and deletion efficiency is high but the query efficiency is slightly lower.
+ * 2. It is BST itself. Compared with Heap which is not completely ordered, RedBlackTree is completely ordered.
+ */
 export class RedBlackTree<
     K = any,
     V = any,
@@ -119,7 +123,7 @@ export class RedBlackTree<
     return new RedBlackTree<K, V, R, NODE, TREE>([], {
       iterationType: this.iterationType,
       isMapMode: this._isMapMode,
-      comparator: this._comparator,
+      extractComparable: this._extractComparable,
       toEntryFn: this._toEntryFn,
       ...options
     }) as TREE;
@@ -351,7 +355,7 @@ export class RedBlackTree<
 
     while (this.isRealNode(current)) {
       parent = current;
-      const compared = this.comparator(node.key, current.key);
+      const compared = this._compare(node.key, current.key);
       if (compared < 0) {
         current = current.left ?? this.NIL;
       } else if (compared > 0) {

package/src/data-structures/binary-tree/tree-multi-map.ts

@@ -139,7 +139,7 @@ export class TreeMultiMap<
     return new TreeMultiMap<K, V, R, NODE, TREE>([], {
       iterationType: this.iterationType,
       isMapMode: this._isMapMode,
-      comparator: this._comparator,
+      extractComparable: this._extractComparable,
       toEntryFn: this._toEntryFn,
       ...options
     }) as TREE;
@@ -173,8 +173,8 @@ export class TreeMultiMap<
       if (this.isKey(key)) return [this.createNode(key, finalValue, 'BLACK', count), finalValue];
     }
 
-    if (this._toEntryFn) {
-      const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw as R);
+    if (this.isRaw(keyNodeEntryOrRaw)) {
+      const [key, entryValue] = this._toEntryFn!(keyNodeEntryOrRaw);
       const finalValue = value ?? entryValue;
       if (this.isKey(key)) return [this.createNode(key, finalValue, 'BLACK', count), finalValue];
     }

package/src/data-structures/heap/heap.ts

@@ -19,9 +19,9 @@ import { IterableElementBase } from '../base';
  * 6. Non-linear Search: While a heap allows rapid access to its largest or smallest element, it is less efficient for other operations, such as searching for a specific element, as it is not designed for these tasks.
  * 7. Efficient Sorting Algorithms: For example, heap sort. Heap sort uses the properties of a heap to sort elements.
  * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prime's minimum-spanning tree algorithm, which use heaps to improve performance.
- * @example 
- * // Use Heap to sort an array 
- * function heapSort(arr: number[]): number[] {
+ * @example
+ * // Use Heap to sort an array
+ *     function heapSort(arr: number[]): number[] {
  *       const heap = new Heap<number>(arr, { comparator: (a, b) => a - b });
  *       const sorted: number[] = [];
  *       while (!heap.isEmpty()) {
@@ -29,12 +29,12 @@ import { IterableElementBase } from '../base';
  *       }
  *       return sorted;
  *     }
- * 
+ *
  *     const array = [5, 3, 8, 4, 1, 2];
  *     console.log(heapSort(array)); // [1, 2, 3, 4, 5, 8]
- * @example 
- * // Use Heap to solve top k problems 
- * function topKElements(arr: number[], k: number): number[] {
+ * @example
+ * // Use Heap to solve top k problems
+ *     function topKElements(arr: number[], k: number): number[] {
  *       const heap = new Heap<number>([], { comparator: (a, b) => b - a }); // Max heap
  *       arr.forEach(num => {
  *         heap.add(num);
@@ -42,28 +42,28 @@ import { IterableElementBase } from '../base';
  *       });
  *       return heap.toArray();
  *     }
- * 
+ *
  *     const numbers = [10, 30, 20, 5, 15, 25];
  *     console.log(topKElements(numbers, 3)); // [15, 10, 5]
- * @example 
- * // Use Heap to merge sorted sequences 
- * function mergeSortedSequences(sequences: number[][]): number[] {
+ * @example
+ * // Use Heap to merge sorted sequences
+ *     function mergeSortedSequences(sequences: number[][]): number[] {
  *       const heap = new Heap<{ value: number; seqIndex: number; itemIndex: number }>([], {
  *         comparator: (a, b) => a.value - b.value // Min heap
  *       });
- * 
+ *
  *       // Initialize heap
  *       sequences.forEach((seq, seqIndex) => {
  *         if (seq.length) {
  *           heap.add({ value: seq[0], seqIndex, itemIndex: 0 });
  *         }
  *       });
- * 
+ *
  *       const merged: number[] = [];
  *       while (!heap.isEmpty()) {
  *         const { value, seqIndex, itemIndex } = heap.poll()!;
  *         merged.push(value);
- * 
+ *
  *         if (itemIndex + 1 < sequences[seqIndex].length) {
  *           heap.add({
  *             value: sequences[seqIndex][itemIndex + 1],
@@ -72,42 +72,42 @@ import { IterableElementBase } from '../base';
  *           });
  *         }
  *       }
- * 
+ *
  *       return merged;
  *     }
- * 
+ *
  *     const sequences = [
  *       [1, 4, 7],
  *       [2, 5, 8],
  *       [3, 6, 9]
  *     ];
  *     console.log(mergeSortedSequences(sequences)); // [1, 2, 3, 4, 5, 6, 7, 8, 9]
- * @example 
- * // Use Heap to dynamically maintain the median 
- * class MedianFinder {
+ * @example
+ * // Use Heap to dynamically maintain the median
+ *     class MedianFinder {
  *       private low: MaxHeap<number>; // Max heap, stores the smaller half
  *       private high: MinHeap<number>; // Min heap, stores the larger half
- * 
+ *
  *       constructor() {
  *         this.low = new MaxHeap<number>([]);
  *         this.high = new MinHeap<number>([]);
  *       }
- * 
+ *
  *       addNum(num: number): void {
  *         if (this.low.isEmpty() || num <= this.low.peek()!) this.low.add(num);
  *         else this.high.add(num);
- * 
+ *
  *         // Balance heaps
  *         if (this.low.size > this.high.size + 1) this.high.add(this.low.poll()!);
  *         else if (this.high.size > this.low.size) this.low.add(this.high.poll()!);
  *       }
- * 
+ *
  *       findMedian(): number {
  *         if (this.low.size === this.high.size) return (this.low.peek()! + this.high.peek()!) / 2;
  *         return this.low.peek()!;
  *       }
  *     }
- * 
+ *
  *     const medianFinder = new MedianFinder();
  *     medianFinder.addNum(10);
  *     console.log(medianFinder.findMedian()); // 10
@@ -119,42 +119,42 @@ import { IterableElementBase } from '../base';
  *     console.log(medianFinder.findMedian()); // 25
  *     medianFinder.addNum(50);
  *     console.log(medianFinder.findMedian()); // 30
- * @example 
- * // Use Heap for load balancing 
- * function loadBalance(requests: number[], servers: number): number[] {
+ * @example
+ * // Use Heap for load balancing
+ *     function loadBalance(requests: number[], servers: number): number[] {
  *       const serverHeap = new Heap<{ id: number; load: number }>([], { comparator: (a, b) => a.load - b.load }); // min heap
  *       const serverLoads = new Array(servers).fill(0);
- * 
+ *
  *       for (let i = 0; i < servers; i++) {
  *         serverHeap.add({ id: i, load: 0 });
  *       }
- * 
+ *
  *       requests.forEach(req => {
  *         const server = serverHeap.poll()!;
  *         serverLoads[server.id] += req;
  *         server.load += req;
  *         serverHeap.add(server); // The server after updating the load is re-entered into the heap
  *       });
- * 
+ *
  *       return serverLoads;
  *     }
- * 
+ *
  *     const requests = [5, 2, 8, 3, 7];
  *     console.log(loadBalance(requests, 3)); // [12, 8, 5]
- * @example 
- * // Use Heap to schedule tasks 
- * type Task = [string, number];
- * 
+ * @example
+ * // Use Heap to schedule tasks
+ *     type Task = [string, number];
+ *
  *     function scheduleTasks(tasks: Task[], machines: number): Map<number, Task[]> {
  *       const machineHeap = new Heap<{ id: number; load: number }>([], { comparator: (a, b) => a.load - b.load }); // Min heap
  *       const allocation = new Map<number, Task[]>();
- * 
+ *
  *       // Initialize the load on each machine
  *       for (let i = 0; i < machines; i++) {
  *         machineHeap.add({ id: i, load: 0 });
  *         allocation.set(i, []);
  *       }
- * 
+ *
  *       // Assign tasks
  *       tasks.forEach(([task, load]) => {
  *         const machine = machineHeap.poll()!;
@@ -162,10 +162,10 @@ import { IterableElementBase } from '../base';
  *         machine.load += load;
  *         machineHeap.add(machine); // The machine after updating the load is re-entered into the heap
  *       });
- * 
+ *
  *       return allocation;
  *     }
- * 
+ *
  *     const tasks: Task[] = [
  *       ['Task1', 3],
  *       ['Task2', 1],