min-heap-typed 1.54.3 → 2.0.0

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

@@ -100,6 +100,7 @@ export class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, M
       specifyComparable: this._specifyComparable,
       toEntryFn: this._toEntryFn,
       isReverse: this._isReverse,
+      isMapMode: this._isMapMode,
       ...options
     });
   }
@@ -108,19 +109,23 @@ export class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, M
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
-   * The function `createNode` overrides the method to create a new AVLTreeMultiMapNode with a
-   * specified key and an empty array of values.
-   * @param {K} key - The `key` parameter in the `createNode` method represents the key of the node
-   * that will be created in the AVLTreeMultiMap.
-   * @returns An AVLTreeMultiMapNode object is being returned, initialized with the provided key and an
-   * empty array.
+   * The `createNode` function in TypeScript overrides the default implementation to create a new
+   * AVLTreeMultiMapNode with a specified key and value array.
+   * @param {K} key - The `key` parameter represents the key of the node being created in the
+   * AVLTreeMultiMap.
+   * @param {V[]} value - The `value` parameter in the `createNode` method represents an array of
+   * values associated with a specific key in the AVLTreeMultiMapNode. If no value is provided when
+   * calling the method, an empty array `[]` is used as the default value.
+   * @returns An AVLTreeMultiMapNode object is being returned, with the specified key and value. If the
+   * AVLTreeMultiMap is in map mode, an empty array is used as the value, otherwise the provided value
+   * array is used.
    */
-  override createNode(key: K): AVLTreeMultiMapNode<K, V> {
-    return new AVLTreeMultiMapNode<K, V>(key, []);
+  override createNode(key: K, value: V[] = []): AVLTreeMultiMapNode<K, V> {
+    return new AVLTreeMultiMapNode<K, V>(key, this._isMapMode ? [] : value);
   }
 
   override add(
-    node: K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined
+    keyNodeOrEntry: K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined
   ): boolean;
 
   override add(key: K, value: V): boolean;
@@ -129,17 +134,16 @@ export class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, M
    * Time Complexity: O(log n)
    * Space Complexity: O(log n)
    *
-   * The function `add` in TypeScript overrides the superclass method to add key-value pairs to an AVL
-   * tree multi-map.
-   * @param {K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | K} keyNodeOrEntry - The `keyNodeOrEntry`
-   * parameter in the `override add` method can be either a key-value pair entry or just a key. If it
-   * is a key-value pair entry, it will be in the format `[key, values]`, where `key` is the key and
-   * `values`
-   * @param {V} [value] - The `value` parameter in the `override add` method represents the value that
-   * you want to add to the AVLTreeMultiMap. It can be a single value or an array of values associated
-   * with a specific key.
-   * @returns The `override add` method is returning a boolean value, which indicates whether the
-   * addition operation was successful or not.
+   * The function `add` in this TypeScript code overrides the superclass method to add key-value pairs
+   * to an AVLTreeMultiMap, handling different input types and scenarios.
+   * @param [key] - The `key` parameter in the `override add` method represents the key of the entry to
+   * be added to the AVLTreeMultiMap. It can be of type `K`, which is the key type of the map. The key
+   * can be a single key value, a node of the AVLTree
+   * @param {V[]} [values] - The `values` parameter in the `add` method represents an array of values
+   * that you want to add to the AVLTreeMultiMap. It can contain one or more values associated with a
+   * specific key.
+   * @returns The `add` method is returning a boolean value, which indicates whether the operation was
+   * successful or not.
    */
   override add(
     keyNodeOrEntry: K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | K,
@@ -150,27 +154,38 @@ export class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, M
     const _commonAdd = (key?: BTNOptKeyOrNull<K>, values?: V[]) => {
       if (key === undefined || key === null) return false;
 
-      const existingValues = this.get(key);
-      if (existingValues !== undefined && values !== undefined) {
-        for (const value of values) existingValues.push(value);
-        return true;
-      }
-
-      const existingNode = this.getNode(key);
-      if (this.isRealNode(existingNode)) {
-        if (existingValues === undefined) {
-          super.add(key, values);
-          return true;
-        }
-        if (values !== undefined) {
+      const _addToValues = () => {
+        const existingValues = this.get(key);
+        if (existingValues !== undefined && values !== undefined) {
           for (const value of values) existingValues.push(value);
           return true;
+        }
+        return false;
+      };
+
+      const _addByNode = () => {
+        const existingNode = this.getNode(key);
+        if (this.isRealNode(existingNode)) {
+          const existingValues = this.get(existingNode);
+          if (existingValues === undefined) {
+            super.add(key, values);
+            return true;
+          }
+          if (values !== undefined) {
+            for (const value of values) existingValues.push(value);
+            return true;
+          } else {
+            return false;
+          }
         } else {
-          return false;
+          return super.add(key, values);
         }
-      } else {
-        return super.add(key, values);
+      };
+
+      if (this._isMapMode) {
+        return _addByNode() || _addToValues();
       }
+      return _addToValues() || _addByNode();
     };
 
     if (this.isEntry(keyNodeOrEntry)) {

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

@@ -60,6 +60,70 @@ export class AVLTreeNode<K = any, V = any> extends BSTNode<K, V> {
  * 5. Efficient Lookups: Offers O(log n) search time, where 'n' is the number of nodes, due to its balanced nature.
  * 6. Complex Insertions and Deletions: Due to rebalancing, these operations are more complex than in a regular BST.
  * 7. Path Length: The path length from the root to any leaf is longer compared to an unbalanced BST, but shorter than a linear chain of nodes.
+ * @example
+ * // Find elements in a range
+ *     // In interval queries, AVL trees, with their strictly balanced structure and lower height, offer better query efficiency, making them ideal for frequent and high-performance interval queries. In contrast, Red-Black trees, with lower update costs, are more suitable for scenarios involving frequent insertions and deletions where the requirements for interval queries are less demanding.
+ *     type Datum = { timestamp: Date; temperature: number };
+ *     // Fixed dataset of CPU temperature readings
+ *     const cpuData: Datum[] = [
+ *       { timestamp: new Date('2024-12-02T00:00:00'), temperature: 55.1 },
+ *       { timestamp: new Date('2024-12-02T00:01:00'), temperature: 56.3 },
+ *       { timestamp: new Date('2024-12-02T00:02:00'), temperature: 54.8 },
+ *       { timestamp: new Date('2024-12-02T00:03:00'), temperature: 57.2 },
+ *       { timestamp: new Date('2024-12-02T00:04:00'), temperature: 58.0 },
+ *       { timestamp: new Date('2024-12-02T00:05:00'), temperature: 59.4 },
+ *       { timestamp: new Date('2024-12-02T00:06:00'), temperature: 60.1 },
+ *       { timestamp: new Date('2024-12-02T00:07:00'), temperature: 61.3 },
+ *       { timestamp: new Date('2024-12-02T00:08:00'), temperature: 62.0 },
+ *       { timestamp: new Date('2024-12-02T00:09:00'), temperature: 63.5 },
+ *       { timestamp: new Date('2024-12-02T00:10:00'), temperature: 64.0 },
+ *       { timestamp: new Date('2024-12-02T00:11:00'), temperature: 62.8 },
+ *       { timestamp: new Date('2024-12-02T00:12:00'), temperature: 61.5 },
+ *       { timestamp: new Date('2024-12-02T00:13:00'), temperature: 60.2 },
+ *       { timestamp: new Date('2024-12-02T00:14:00'), temperature: 59.8 },
+ *       { timestamp: new Date('2024-12-02T00:15:00'), temperature: 58.6 },
+ *       { timestamp: new Date('2024-12-02T00:16:00'), temperature: 57.4 },
+ *       { timestamp: new Date('2024-12-02T00:17:00'), temperature: 56.2 },
+ *       { timestamp: new Date('2024-12-02T00:18:00'), temperature: 55.7 },
+ *       { timestamp: new Date('2024-12-02T00:19:00'), temperature: 54.5 },
+ *       { timestamp: new Date('2024-12-02T00:20:00'), temperature: 53.2 },
+ *       { timestamp: new Date('2024-12-02T00:21:00'), temperature: 52.8 },
+ *       { timestamp: new Date('2024-12-02T00:22:00'), temperature: 51.9 },
+ *       { timestamp: new Date('2024-12-02T00:23:00'), temperature: 50.5 },
+ *       { timestamp: new Date('2024-12-02T00:24:00'), temperature: 49.8 },
+ *       { timestamp: new Date('2024-12-02T00:25:00'), temperature: 48.7 },
+ *       { timestamp: new Date('2024-12-02T00:26:00'), temperature: 47.5 },
+ *       { timestamp: new Date('2024-12-02T00:27:00'), temperature: 46.3 },
+ *       { timestamp: new Date('2024-12-02T00:28:00'), temperature: 45.9 },
+ *       { timestamp: new Date('2024-12-02T00:29:00'), temperature: 45.0 }
+ *     ];
+ *
+ *     // Create an AVL tree to store CPU temperature data
+ *     const cpuTemperatureTree = new AVLTree<Date, number, Datum>(cpuData, {
+ *       toEntryFn: ({ timestamp, temperature }) => [timestamp, temperature]
+ *     });
+ *
+ *     // Query a specific time range (e.g., from 00:05 to 00:15)
+ *     const rangeStart = new Date('2024-12-02T00:05:00');
+ *     const rangeEnd = new Date('2024-12-02T00:15:00');
+ *     const rangeResults = cpuTemperatureTree.rangeSearch([rangeStart, rangeEnd], node => ({
+ *       minute: node ? node.key.getMinutes() : 0,
+ *       temperature: cpuTemperatureTree.get(node ? node.key : undefined)
+ *     }));
+ *
+ *     console.log(rangeResults); // [
+ *  //      { minute: 5, temperature: 59.4 },
+ *  //      { minute: 6, temperature: 60.1 },
+ *  //      { minute: 7, temperature: 61.3 },
+ *  //      { minute: 8, temperature: 62 },
+ *  //      { minute: 9, temperature: 63.5 },
+ *  //      { minute: 10, temperature: 64 },
+ *  //      { minute: 11, temperature: 62.8 },
+ *  //      { minute: 12, temperature: 61.5 },
+ *  //      { minute: 13, temperature: 60.2 },
+ *  //      { minute: 14, temperature: 59.8 },
+ *  //      { minute: 15, temperature: 58.6 }
+ *  //    ]
  */
 export class AVLTree<K = any, V = any, R = object, MK = any, MV = any, MR = object>
   extends BST<K, V, R, MK, MV, MR>

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

@@ -544,7 +544,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
     const queue = new Queue<BinaryTreeNode<K, V>>([this._root]);
     let potentialParent: BinaryTreeNode<K, V> | undefined; // Record the parent node of the potential insertion location
 
-    while (queue.size > 0) {
+    while (queue.length > 0) {
       const cur = queue.shift();
 
       if (!cur) continue;
@@ -1530,7 +1530,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
       ]);
 
       const dfs = (level: number) => {
-        if (queue.size === 0) return;
+        if (queue.length === 0) return;
 
         const current = queue.shift()!;
         ans.push(callback(current));
@@ -1549,8 +1549,8 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
       dfs(0);
     } else {
       const queue = new Queue<OptNodeOrNull<BinaryTreeNode<K, V>>>([startNode]);
-      while (queue.size > 0) {
-        const levelSize = queue.size;
+      while (queue.length > 0) {
+        const levelSize = queue.length;
 
         for (let i = 0; i < levelSize; i++) {
           const current = queue.shift()!;
@@ -1609,7 +1609,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
       dfs(startNode);
     } else {
       const queue = new Queue([startNode]);
-      while (queue.size > 0) {
+      while (queue.length > 0) {
         const cur = queue.shift();
         if (this.isRealNode(cur)) {
           if (this.isLeaf(cur)) {

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

@@ -441,14 +441,14 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
       if (arr.length === 0) return;
 
       const mid = Math.floor((arr.length - 1) / 2);
-      let { key, value } = arr[mid];
+      const { key, value } = arr[mid];
       const { orgIndex } = arr[mid];
       if (this.isRaw(key)) {
         const entry = this._toEntryFn!(key);
-        key = entry[0];
-        value = entry[1] ?? value;
+        inserted[orgIndex] = this.add(entry);
+      } else {
+        inserted[orgIndex] = this.add(key, value);
       }
-      inserted[orgIndex] = this.add(key, value);
       _dfs(arr.slice(0, mid));
       _dfs(arr.slice(mid + 1));
     };
@@ -462,14 +462,14 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
           const [l, r] = popped;
           if (l <= r) {
             const m = l + Math.floor((r - l) / 2);
-            let { key, value } = sorted[m];
+            const { key, value } = sorted[m];
             const { orgIndex } = sorted[m];
             if (this.isRaw(key)) {
               const entry = this._toEntryFn!(key);
-              key = entry[0];
-              value = entry[1] ?? value;
+              inserted[orgIndex] = this.add(entry);
+            } else {
+              inserted[orgIndex] = this.add(key, value);
             }
-            inserted[orgIndex] = this.add(key, value);
             stack.push([m + 1, r]);
             stack.push([l, m - 1]);
           }
@@ -792,7 +792,7 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
       return ans;
     } else {
       const queue = new Queue<BSTNode<K, V>>([this._root]);
-      while (queue.size > 0) {
+      while (queue.length > 0) {
         const cur = queue.shift();
         if (this.isRealNode(cur)) {
           const compared = this._compare(cur.key, targetKey);

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

@@ -21,7 +21,7 @@ export class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode<K, V[]>
    * @param {V[]} value - The `value` parameter in the constructor represents an array of values of
    * type `V`.
    */
-  constructor(key: K, value: V[]) {
+  constructor(key: K, value?: V[]) {
     super(key, value);
   }
 
@@ -55,11 +55,169 @@ export class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode<K, V[]>
 /**
  *
  * @example
- * // Find elements in a range
- *     const tmm = new TreeMultiMap<number>([10, 5, 15, 3, 7, 12, 18]);
- *     console.log(tmm.search(new Range(5, 10))); // [5, 7, 10]
- *     console.log(tmm.search(new Range(4, 12))); // [5, 7, 10, 12]
- *     console.log(tmm.search(new Range(15, 20))); // [15, 18]
+ * // players ranked by score with their equipment
+ *     type Equipment = {
+ *       name: string; // Equipment name
+ *       quality: 'legendary' | 'epic' | 'rare' | 'common';
+ *       level: number;
+ *     };
+ *
+ *     type Player = {
+ *       name: string;
+ *       score: number;
+ *       equipments: Equipment[];
+ *     };
+ *
+ *     // Mock player data with their scores and equipment
+ *     const players: Player[] = [
+ *       {
+ *         name: 'DragonSlayer',
+ *         score: 8750,
+ *         equipments: [
+ *           { name: 'AWM', quality: 'legendary', level: 85 },
+ *           { name: 'Level 3 Helmet', quality: 'epic', level: 80 },
+ *           { name: 'Extended Quickdraw Mag', quality: 'rare', level: 75 },
+ *           { name: 'Compensator', quality: 'epic', level: 78 },
+ *           { name: 'Vertical Grip', quality: 'rare', level: 72 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'ShadowNinja',
+ *         score: 7200,
+ *         equipments: [
+ *           { name: 'M416', quality: 'epic', level: 75 },
+ *           { name: 'Ghillie Suit', quality: 'rare', level: 70 },
+ *           { name: 'Red Dot Sight', quality: 'common', level: 65 },
+ *           { name: 'Extended QuickDraw Mag', quality: 'rare', level: 68 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'RuneMaster',
+ *         score: 9100,
+ *         equipments: [
+ *           { name: 'KAR98K', quality: 'legendary', level: 90 },
+ *           { name: 'Level 3 Vest', quality: 'legendary', level: 85 },
+ *           { name: 'Holographic Sight', quality: 'epic', level: 82 },
+ *           { name: 'Suppressor', quality: 'legendary', level: 88 },
+ *           { name: 'Level 3 Backpack', quality: 'epic', level: 80 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'BattleKing',
+ *         score: 8500,
+ *         equipments: [
+ *           { name: 'AUG', quality: 'epic', level: 82 },
+ *           { name: 'Red Dot Sight', quality: 'rare', level: 75 },
+ *           { name: 'Extended Mag', quality: 'common', level: 70 },
+ *           { name: 'Tactical Stock', quality: 'rare', level: 76 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'SniperElite',
+ *         score: 7800,
+ *         equipments: [
+ *           { name: 'M24', quality: 'legendary', level: 88 },
+ *           { name: 'Compensator', quality: 'epic', level: 80 },
+ *           { name: 'Scope 8x', quality: 'legendary', level: 85 },
+ *           { name: 'Level 2 Helmet', quality: 'rare', level: 75 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'RushMaster',
+ *         score: 7500,
+ *         equipments: [
+ *           { name: 'Vector', quality: 'rare', level: 72 },
+ *           { name: 'Level 2 Helmet', quality: 'common', level: 65 },
+ *           { name: 'Quickdraw Mag', quality: 'common', level: 60 },
+ *           { name: 'Laser Sight', quality: 'rare', level: 68 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'GhostWarrior',
+ *         score: 8200,
+ *         equipments: [
+ *           { name: 'SCAR-L', quality: 'epic', level: 78 },
+ *           { name: 'Extended Quickdraw Mag', quality: 'rare', level: 70 },
+ *           { name: 'Holographic Sight', quality: 'epic', level: 75 },
+ *           { name: 'Suppressor', quality: 'rare', level: 72 },
+ *           { name: 'Vertical Grip', quality: 'common', level: 65 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'DeathDealer',
+ *         score: 7300,
+ *         equipments: [
+ *           { name: 'SKS', quality: 'epic', level: 76 },
+ *           { name: 'Holographic Sight', quality: 'rare', level: 68 },
+ *           { name: 'Extended Mag', quality: 'common', level: 65 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'StormRider',
+ *         score: 8900,
+ *         equipments: [
+ *           { name: 'MK14', quality: 'legendary', level: 92 },
+ *           { name: 'Level 3 Backpack', quality: 'legendary', level: 85 },
+ *           { name: 'Scope 8x', quality: 'epic', level: 80 },
+ *           { name: 'Suppressor', quality: 'legendary', level: 88 },
+ *           { name: 'Tactical Stock', quality: 'rare', level: 75 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'CombatLegend',
+ *         score: 7600,
+ *         equipments: [
+ *           { name: 'UMP45', quality: 'rare', level: 74 },
+ *           { name: 'Level 2 Vest', quality: 'common', level: 67 },
+ *           { name: 'Red Dot Sight', quality: 'common', level: 62 },
+ *           { name: 'Extended Mag', quality: 'rare', level: 70 }
+ *         ]
+ *       }
+ *     ];
+ *
+ *     // Create a TreeMultiMap for player rankings
+ *     const playerRankings = new TreeMultiMap<number, Equipment, Player>(players, {
+ *       toEntryFn: ({ score, equipments }) => [score, equipments],
+ *       isMapMode: false
+ *     });
+ *
+ *     const topPlayersEquipments = playerRankings.rangeSearch([8900, 10000], node => playerRankings.get(node));
+ *     console.log(topPlayersEquipments); // [
+ *  //      [
+ *  //        {
+ *  //          name: 'MK14',
+ *  //          quality: 'legendary',
+ *  //          level: 92
+ *  //        },
+ *  //        { name: 'Level 3 Backpack', quality: 'legendary', level: 85 },
+ *  //        {
+ *  //          name: 'Scope 8x',
+ *  //          quality: 'epic',
+ *  //          level: 80
+ *  //        },
+ *  //        { name: 'Suppressor', quality: 'legendary', level: 88 },
+ *  //        {
+ *  //          name: 'Tactical Stock',
+ *  //          quality: 'rare',
+ *  //          level: 75
+ *  //        }
+ *  //      ],
+ *  //      [
+ *  //        { name: 'KAR98K', quality: 'legendary', level: 90 },
+ *  //        {
+ *  //          name: 'Level 3 Vest',
+ *  //          quality: 'legendary',
+ *  //          level: 85
+ *  //        },
+ *  //        { name: 'Holographic Sight', quality: 'epic', level: 82 },
+ *  //        {
+ *  //          name: 'Suppressor',
+ *  //          quality: 'legendary',
+ *  //          level: 88
+ *  //        },
+ *  //        { name: 'Level 3 Backpack', quality: 'epic', level: 80 }
+ *  //      ]
+ *  //    ]
  */
 export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR = object>
   extends RedBlackTree<K, V[], R, MK, MV[], MR>
@@ -82,7 +240,7 @@ export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR =
     > = [],
     options?: TreeMultiMapOptions<K, V[], R>
   ) {
-    super([], { ...options, isMapMode: true });
+    super([], { ...options });
     if (keysNodesEntriesOrRaws) {
       this.addMany(keysNodesEntriesOrRaws);
     }
@@ -107,6 +265,7 @@ export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR =
       specifyComparable: this._specifyComparable,
       toEntryFn: this._toEntryFn,
       isReverse: this._isReverse,
+      isMapMode: this._isMapMode,
       ...options
     });
   }
@@ -115,18 +274,23 @@ export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR =
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
-   * The function `createNode` overrides the method to create a new `TreeMultiMapNode` with a specified
-   * key and an empty array of values.
-   * @param {K} key - The `key` parameter in the `createNode` method represents the key of the node
-   * that will be created in the TreeMultiMap data structure.
-   * @returns A new instance of `TreeMultiMapNode<K, V>` is being returned, with the specified key and
-   * an empty array as its value.
+   * The function `createNode` overrides the creation of a new TreeMultiMapNode with a specified key
+   * and value array.
+   * @param {K} key - The `key` parameter represents the key of the node being created in the
+   * `TreeMultiMap`.
+   * @param {V[]} value - The `value` parameter in the `createNode` method represents an array of
+   * values associated with a specific key in the TreeMultiMap data structure.
+   * @returns A new instance of `TreeMultiMapNode<K, V>` is being returned with the specified key and
+   * value. If `_isMapMode` is true, an empty array is passed as the value, otherwise the provided
+   * value is used.
    */
-  override createNode(key: K): TreeMultiMapNode<K, V> {
-    return new TreeMultiMapNode<K, V>(key, []);
+  override createNode(key: K, value: V[] = []): TreeMultiMapNode<K, V> {
+    return new TreeMultiMapNode<K, V>(key, this._isMapMode ? [] : value);
   }
 
-  override add(node: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined): boolean;
+  override add(
+    keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined
+  ): boolean;
 
   override add(key: K, value: V): boolean;
 
@@ -134,14 +298,13 @@ export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR =
    * Time Complexity: O(log n)
    * Space Complexity: O(log n)
    *
-   * The function `add` in TypeScript overrides the superclass method to add key-value pairs to a
-   * TreeMultiMapNode, handling different input types and scenarios.
-   * @param {K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined} keyNodeOrEntry - The `keyNodeOrEntry`
-   * parameter in the `override add` method can be either a `BTNRep` object containing a key, an array
-   * of values, and a `TreeMultiMapNode`, or just a key.
-   * @param {V} [value] - The `value` parameter in the `override add` method represents the value that
-   * you want to add to the TreeMultiMap. If the key is already present in the map, the new value will
-   * be added to the existing list of values associated with that key. If the key is not present,
+   * The function overrides the add method to handle different types of input for a TreeMultiMap data
+   * structure.
+   * @param [key] - The `key` parameter in the `override add` method represents the key of the entry to
+   * be added to the TreeMultiMap. It can be of type `K`, which is the key type of the TreeMultiMap, or
+   * it can be a TreeMultiMapNode containing the key and its
+   * @param {V[]} [values] - The `values` parameter in the `add` method represents an array of values
+   * that you want to add to the TreeMultiMap. It can contain one or more values of type `V`.
    * @returns The `add` method is returning a boolean value, which indicates whether the operation was
    * successful or not.
    */
@@ -154,27 +317,38 @@ export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR =
     const _commonAdd = (key?: BTNOptKeyOrNull<K>, values?: V[]) => {
       if (key === undefined || key === null) return false;
 
-      const existingValues = this.get(key);
-      if (existingValues !== undefined && values !== undefined) {
-        for (const value of values) existingValues.push(value);
-        return true;
-      }
-
-      const existingNode = this.getNode(key);
-      if (this.isRealNode(existingNode)) {
-        if (existingValues === undefined) {
-          super.add(key, values);
-          return true;
-        }
-        if (values !== undefined) {
+      const _addToValues = () => {
+        const existingValues = this.get(key);
+        if (existingValues !== undefined && values !== undefined) {
           for (const value of values) existingValues.push(value);
           return true;
+        }
+        return false;
+      };
+
+      const _addByNode = () => {
+        const existingNode = this.getNode(key);
+        if (this.isRealNode(existingNode)) {
+          const existingValues = this.get(existingNode);
+          if (existingValues === undefined) {
+            super.add(key, values);
+            return true;
+          }
+          if (values !== undefined) {
+            for (const value of values) existingValues.push(value);
+            return true;
+          } else {
+            return false;
+          }
         } else {
-          return false;
+          return super.add(key, values);
         }
-      } else {
-        return super.add(key, values);
+      };
+
+      if (this._isMapMode) {
+        return _addByNode() || _addToValues();
       }
+      return _addToValues() || _addByNode();
     };
 
     if (this.isEntry(keyNodeOrEntry)) {

package/src/data-structures/graph/abstract-graph.ts

@@ -356,8 +356,8 @@ export abstract class AbstractGraph<
       const queue = new Queue<VO>([vertex1]);
       visited.set(vertex1, true);
       let cost = 0;
-      while (queue.size > 0) {
-        for (let i = 0; i < queue.size; i++) {
+      while (queue.length > 0) {
+        for (let i = 0; i < queue.length; i++) {
           const cur = queue.shift();
           if (cur === vertex2) {
             return cost;

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

@@ -185,7 +185,7 @@ import { IterableElementBase } from '../base';
  *     ]);
  *     console.log(scheduleTasks(tasks, 2)); // expectedMap
  */
-export class Heap<E = any, R = any> extends IterableElementBase<E, R, Heap<E, R>> {
+export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
   /**
    * The constructor initializes a heap data structure with optional elements and options.
    * @param elements - The `elements` parameter is an iterable object that contains the initial
@@ -416,17 +416,6 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R, Heap<E, R>
     return result;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * Convert the heap to an array.
-   * @returns An array containing the elements of the heap.
-   */
-  toArray(): E[] {
-    return [...this.elements];
-  }
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -483,7 +472,7 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R, Heap<E, R>
    * @returns The `filter` method is returning a new `Heap` object that contains the elements that pass
    * the filter condition specified by the `callback` function.
    */
-  filter(callback: ElementCallback<E, R, boolean, Heap<E, R>>, thisArg?: any): Heap<E, R> {
+  filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): Heap<E, R> {
     const filteredList = new Heap<E, R>([], { toElementFn: this.toElementFn, comparator: this.comparator });
     let index = 0;
     for (const current of this) {
@@ -517,7 +506,7 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R, Heap<E, R>
    * @returns a new instance of the `Heap` class with the mapped elements.
    */
   map<EM, RM>(
-    callback: ElementCallback<E, R, EM, Heap<E, R>>,
+    callback: ElementCallback<E, R, EM>,
     comparator: Comparator<EM>,
     toElementFn?: (rawElement: RM) => EM,
     thisArg?: any