priority-queue-typed 1.54.2 → 2.0.0

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

@@ -5,11 +5,13 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BTNOptKeyOrNull, BTNRep, OptNodeOrNull, TreeMultiMapOptions } from '../../types';
+import type { BTNOptKeyOrNull, TreeMultiMapOptions } from '../../types';
 import { RedBlackTree, RedBlackTreeNode } from './red-black-tree';
 import { IBinaryTree } from '../../interfaces';
 
 export class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode<K, V[]> {
+  override parent?: TreeMultiMapNode<K, V> = undefined;
+
   /**
    * This TypeScript constructor initializes an object with a key of type K and an array of values of
    * type V.
@@ -19,32 +21,30 @@ 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);
   }
 
-  override parent?: TreeMultiMapNode<K, V> = undefined;
-
-  override _left?: OptNodeOrNull<TreeMultiMapNode<K, V>> = undefined;
+  override _left?: TreeMultiMapNode<K, V> | null | undefined = undefined;
 
-  override get left(): OptNodeOrNull<TreeMultiMapNode<K, V>> {
+  override get left(): TreeMultiMapNode<K, V> | null | undefined {
     return this._left;
   }
 
-  override set left(v: OptNodeOrNull<TreeMultiMapNode<K, V>>) {
+  override set left(v: TreeMultiMapNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
     this._left = v;
   }
 
-  override _right?: OptNodeOrNull<TreeMultiMapNode<K, V>> = undefined;
+  override _right?: TreeMultiMapNode<K, V> | null | undefined = undefined;
 
-  override get right(): OptNodeOrNull<TreeMultiMapNode<K, V>> {
+  override get right(): TreeMultiMapNode<K, V> | null | undefined {
     return this._right;
   }
 
-  override set right(v: OptNodeOrNull<TreeMultiMapNode<K, V>>) {
+  override set right(v: TreeMultiMapNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
@@ -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, 10, 7]
- *     console.log(tmm.search(new Range(4, 12))); // [5, 10, 12, 7]
- *     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>
@@ -77,10 +235,12 @@ export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR =
    * additional options for configuring the TreeMultiMap instance.
    */
   constructor(
-    keysNodesEntriesOrRaws: Iterable<BTNRep<K, V[], TreeMultiMapNode<K, V>> | R> = [],
+    keysNodesEntriesOrRaws: Iterable<
+      K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | R
+    > = [],
     options?: TreeMultiMapOptions<K, V[], R>
   ) {
-    super([], { ...options, isMapMode: true });
+    super([], { ...options });
     if (keysNodesEntriesOrRaws) {
       this.addMany(keysNodesEntriesOrRaws);
     }
@@ -105,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
     });
   }
@@ -113,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: BTNRep<K, V[], TreeMultiMapNode<K, V>>): boolean;
+  override add(
+    keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined
+  ): boolean;
 
   override add(key: K, value: V): boolean;
 
@@ -132,44 +298,57 @@ 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 {BTNRep<K, V[], TreeMultiMapNode<K, V>> | K} 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.
    */
-  override add(keyNodeOrEntry: BTNRep<K, V[], TreeMultiMapNode<K, V>> | K, value?: V): boolean {
+  override add(
+    keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined,
+    value?: V
+  ): boolean {
     if (this.isRealNode(keyNodeOrEntry)) return super.add(keyNodeOrEntry);
 
     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)) {
@@ -186,7 +365,7 @@ export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR =
    *
    * The function `deleteValue` removes a specific value from a key in a TreeMultiMap data structure
    * and deletes the entire node if no values are left for that key.
-   * @param {BTNRep<K, V[], TreeMultiMapNode<K, V>> | K} keyNodeOrEntry - The `keyNodeOrEntry`
+   * @param {K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined} keyNodeOrEntry - The `keyNodeOrEntry`
    * parameter in the `deleteValue` function can be either a `BTNRep` object containing a key and an
    * array of values, or just a key itself.
    * @param {V} value - The `value` parameter in the `deleteValue` function represents the specific
@@ -196,7 +375,10 @@ export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR =
    * @returns The `deleteValue` function returns a boolean value - `true` if the specified `value` was
    * successfully deleted from the values associated with the `keyNodeOrEntry`, and `false` otherwise.
    */
-  deleteValue(keyNodeOrEntry: BTNRep<K, V[], TreeMultiMapNode<K, V>> | K, value: V): boolean {
+  deleteValue(
+    keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined,
+    value: V
+  ): boolean {
     const values = this.get(keyNodeOrEntry);
     if (Array.isArray(values)) {
       const index = values.indexOf(value);

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

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

@@ -61,7 +61,7 @@ export class MaxHeap<E = any, R = any> extends Heap<E, R> {
    * @returns The `filter` method is returning a new `MaxHeap` object that contains the elements that pass
    * the filter condition specified by the `callback` function.
    */
-  override filter(callback: ElementCallback<E, R, boolean, MaxHeap<E, R>>, thisArg?: any): MaxHeap<E, R> {
+  override filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): MaxHeap<E, R> {
     const filteredList = new MaxHeap<E, R>([], { toElementFn: this.toElementFn, comparator: this.comparator });
     let index = 0;
     for (const current of this) {
@@ -95,7 +95,7 @@ export class MaxHeap<E = any, R = any> extends Heap<E, R> {
    * @returns a new instance of the `MaxHeap` class with the mapped elements.
    */
   override map<EM, RM>(
-    callback: ElementCallback<E, R, EM, MaxHeap<E, R>>,
+    callback: ElementCallback<E, R, EM>,
     comparator: Comparator<EM>,
     toElementFn?: (rawElement: RM) => EM,
     thisArg?: any

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

@@ -49,7 +49,7 @@ export class MinHeap<E = any, R = any> extends Heap<E, R> {
    * @returns The `filter` method is returning a new `MinHeap` object that contains the elements that pass
    * the filter condition specified by the `callback` function.
    */
-  override filter(callback: ElementCallback<E, R, boolean, MinHeap<E, R>>, thisArg?: any): MinHeap<E, R> {
+  override filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): MinHeap<E, R> {
     const filteredList = new MinHeap<E, R>([], { toElementFn: this.toElementFn, comparator: this.comparator });
     let index = 0;
     for (const current of this) {
@@ -83,7 +83,7 @@ export class MinHeap<E = any, R = any> extends Heap<E, R> {
    * @returns a new instance of the `MinHeap` class with the mapped elements.
    */
   override map<EM, RM>(
-    callback: ElementCallback<E, R, EM, MinHeap<E, R>>,
+    callback: ElementCallback<E, R, EM>,
     comparator: Comparator<EM>,
     toElementFn?: (rawElement: RM) => EM,
     thisArg?: any