min-heap-typed 1.49.8 → 1.50.0

package/dist/data-structures/hash/hash-map.d.ts

@@ -13,22 +13,24 @@ import { IterableEntryBase } from '../base';
  * 3. Unique Keys: Keys are unique. If you try to insert another entry with the same key, the old entry will be replaced by the new one.
  * 4. Unordered Collection: HashMap does not guarantee the order of entries, and the order may change over time.
  */
-export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
+export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K, V> {
     protected _store: {
         [key: string]: HashMapStoreItem<K, V>;
     };
     protected _objMap: Map<object, V>;
     /**
-     * The constructor function initializes a new instance of a class with optional entries and options.
-     * @param entries - The `entries` parameter is an iterable containing key-value pairs `[K, V]`. It
-     * is optional and defaults to an empty array `[]`. This parameter is used to initialize the map with
-     * key-value pairs.
-     * @param [options] - The `options` parameter is an optional object that can contain additional
-     * configuration options for the constructor. In this case, it has one property:
+     * The constructor function initializes a HashMap object with an optional initial collection and
+     * options.
+     * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements of type
+     * `T`. It is an optional parameter and its default value is an empty array `[]`.
+     * @param [options] - The `options` parameter is an optional object that can contain two properties:
      */
-    constructor(entries?: Iterable<[K, V]>, options?: HashMapOptions<K>);
+    constructor(rawCollection?: Iterable<R>, options?: HashMapOptions<K, V, R>);
+    protected _toEntryFn: (rawElement: R) => [K, V];
+    get toEntryFn(): (rawElement: R) => [K, V];
     protected _size: number;
     get size(): number;
+    isEntry(rawElement: any): rawElement is [K, V];
     isEmpty(): boolean;
     clear(): void;
     /**
@@ -42,11 +44,13 @@ export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
      */
     set(key: K, value: V): boolean;
     /**
-     * The function "setMany" sets multiple key-value pairs in a map.
-     * @param entries - The `entries` parameter is an iterable containing key-value pairs. Each
-     * key-value pair is represented as an array with two entries: the key and the value.
+     * The function `setMany` takes an iterable collection of objects, maps each object to a key-value
+     * pair using a mapping function, and sets each key-value pair in the current object.
+     * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements of type
+     * `T`.
+     * @returns The `setMany` function is returning an array of booleans.
      */
-    setMany(entries: Iterable<[K, V]>): boolean[];
+    setMany(rawCollection: Iterable<R>): boolean[];
     /**
      * The `get` function retrieves a value from a map based on a given key, either from an object map or
      * a string map.

package/dist/data-structures/hash/hash-map.js

@@ -11,32 +11,49 @@ const utils_1 = require("../../utils");
  */
 class HashMap extends base_1.IterableEntryBase {
     /**
-     * The constructor function initializes a new instance of a class with optional entries and options.
-     * @param entries - The `entries` parameter is an iterable containing key-value pairs `[K, V]`. It
-     * is optional and defaults to an empty array `[]`. This parameter is used to initialize the map with
-     * key-value pairs.
-     * @param [options] - The `options` parameter is an optional object that can contain additional
-     * configuration options for the constructor. In this case, it has one property:
+     * The constructor function initializes a HashMap object with an optional initial collection and
+     * options.
+     * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements of type
+     * `T`. It is an optional parameter and its default value is an empty array `[]`.
+     * @param [options] - The `options` parameter is an optional object that can contain two properties:
      */
-    constructor(entries = [], options) {
+    constructor(rawCollection = [], options) {
         super();
         this._store = {};
         this._objMap = new Map();
+        this._toEntryFn = (rawElement) => {
+            if (this.isEntry(rawElement)) {
+                // TODO, For performance optimization, it may be necessary to only inspect the first element traversed.
+                return rawElement;
+            }
+            else {
+                throw new Error("If the provided rawCollection does not adhere to the [key, value] type format, the toEntryFn in the constructor's options parameter needs to specified.");
+            }
+        };
         this._size = 0;
         this._hashFn = (key) => String(key);
         if (options) {
-            const { hashFn } = options;
+            const { hashFn, toEntryFn } = options;
             if (hashFn) {
                 this._hashFn = hashFn;
             }
+            if (toEntryFn) {
+                this._toEntryFn = toEntryFn;
+            }
         }
-        if (entries) {
-            this.setMany(entries);
+        if (rawCollection) {
+            this.setMany(rawCollection);
         }
     }
+    get toEntryFn() {
+        return this._toEntryFn;
+    }
     get size() {
         return this._size;
     }
+    isEntry(rawElement) {
+        return Array.isArray(rawElement) && rawElement.length === 2;
+    }
     isEmpty() {
         return this.size === 0;
     }
@@ -71,14 +88,18 @@ class HashMap extends base_1.IterableEntryBase {
         return true;
     }
     /**
-     * The function "setMany" sets multiple key-value pairs in a map.
-     * @param entries - The `entries` parameter is an iterable containing key-value pairs. Each
-     * key-value pair is represented as an array with two entries: the key and the value.
+     * The function `setMany` takes an iterable collection of objects, maps each object to a key-value
+     * pair using a mapping function, and sets each key-value pair in the current object.
+     * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements of type
+     * `T`.
+     * @returns The `setMany` function is returning an array of booleans.
      */
-    setMany(entries) {
+    setMany(rawCollection) {
         const results = [];
-        for (const [key, value] of entries)
+        for (const rawEle of rawCollection) {
+            const [key, value] = this.toEntryFn(rawEle);
             results.push(this.set(key, value));
+        }
         return results;
     }
     /**

package/dist/types/data-structures/hash/hash-map.d.ts

@@ -8,8 +8,9 @@ export type LinkedHashMapOptions<K> = {
     hashFn?: (key: K) => string;
     objHashFn?: (key: K) => object;
 };
-export type HashMapOptions<K> = {
+export type HashMapOptions<K, V, T> = {
     hashFn?: (key: K) => string;
+    toEntryFn?: (rawElement: T) => [K, V];
 };
 export type HashMapStoreItem<K, V> = {
     key: K;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "min-heap-typed",
-  "version": "1.49.8",
+  "version": "1.50.0",
   "description": "Min Heap. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -132,6 +132,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.49.8"
+    "data-structure-typed": "^1.50.0"
   }
 }

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

@@ -98,16 +98,6 @@ export class AVLTree<
     return keyOrNodeOrEntry instanceof AVLTreeNode;
   }
 
-  /**
-   * The function "isNotNodeInstance" checks if a potential key is a K.
-   * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-   * data type.
-   * @returns a boolean value indicating whether the potentialKey is of type number or not.
-   */
-  override isNotNodeInstance(potentialKey: KeyOrNodeOrEntry<K, V, N>): potentialKey is K {
-    return !(potentialKey instanceof AVLTreeNode);
-  }
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)

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

@@ -196,7 +196,7 @@ export class BinaryTree<
       }
     } else if (this.isNode(keyOrNodeOrEntry)) {
       node = keyOrNodeOrEntry;
-    } else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+    } else if (!this.isNode(keyOrNodeOrEntry)) {
       node = this.createNode(keyOrNodeOrEntry, value);
     } else {
       return;
@@ -292,16 +292,6 @@ export class BinaryTree<
     return this.isRealNode(node) || node === null;
   }
 
-  /**
-   * The function "isNotNodeInstance" checks if a potential key is a K.
-   * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-   * data type.
-   * @returns a boolean value indicating whether the potentialKey is of type number or not.
-   */
-  isNotNodeInstance(potentialKey: KeyOrNodeOrEntry<K, V, N>): potentialKey is K {
-    return !(potentialKey instanceof BinaryTreeNode);
-  }
-
   /**
    * Time Complexity O(log n) - O(n)
    * Space Complexity O(1)
@@ -1028,7 +1018,7 @@ export class BinaryTree<
    *
    * The function `getPathToRoot` returns an array of nodes from a given node to the root of a tree
    * structure, with the option to reverse the order of the nodes.
-   * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+   * @param {K | N | null | undefined} beginNode - The `beginRoot` parameter represents the
    * starting node from which you want to find the path to the root. It can be of type `K`, `N`,
    * `null`, or `undefined`.
    * @param [isReverse=true] - The `isReverse` parameter is a boolean flag that determines whether the
@@ -1036,20 +1026,20 @@ export class BinaryTree<
    * reversed before returning it. If `isReverse` is set to `false`, the path will be returned as is
    * @returns The function `getPathToRoot` returns an array of nodes (`N[]`).
    */
-  getPathToRoot(beginRoot: KeyOrNodeOrEntry<K, V, N>, isReverse = true): N[] {
+  getPathToRoot(beginNode: KeyOrNodeOrEntry<K, V, N>, isReverse = true): N[] {
     // TODO to support get path through passing key
     const result: N[] = [];
-    beginRoot = this.ensureNode(beginRoot);
+    beginNode = this.ensureNode(beginNode);
 
-    if (!beginRoot) return result;
+    if (!beginNode) return result;
 
-    while (beginRoot.parent) {
+    while (beginNode.parent) {
       // Array.push + Array.reverse is more efficient than Array.unshift
       // TODO may consider using Deque, so far this is not the performance bottleneck
-      result.push(beginRoot);
-      beginRoot = beginRoot.parent;
+      result.push(beginNode);
+      beginNode = beginNode.parent;
     }
-    result.push(beginRoot);
+    result.push(beginNode);
     return isReverse ? result.reverse() : result;
   }
 
@@ -1202,99 +1192,94 @@ export class BinaryTree<
     }
   }
 
-  /**
-   * Time complexity: O(n)
-   * Space complexity: O(log n)
-   */
-
-  subTreeTraverse<C extends BTNCallback<N>>(
-    callback?: C,
-    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
-    iterationType?: IterationType,
-    includeNull?: false
-  ): ReturnType<C>[];
-
-  subTreeTraverse<C extends BTNCallback<N>>(
-    callback?: C,
-    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
-    iterationType?: IterationType,
-    includeNull?: undefined
-  ): ReturnType<C>[];
-
-  subTreeTraverse<C extends BTNCallback<N | null | undefined>>(
-    callback?: C,
-    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
-    iterationType?: IterationType,
-    includeNull?: true
-  ): ReturnType<C>[];
-
-  /**
-   * Time complexity: O(n)
-   * Space complexity: O(log n)
-   *
-   * The function `subTreeTraverse` traverses a binary tree and applies a callback function to each
-   * node, either recursively or iteratively.
-   * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-   * the subtree traversal. It takes a single parameter, which is the current node being traversed, and
-   * returns a value of any type.
-   * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
-   * starting node or key from which the subtree traversal should begin. It can be of type `K`,
-   * `N`, `null`, or `undefined`. If not provided, the `root` property of the current object is used as
-   * the default value.
-   * @param iterationType - The `iterationType` parameter determines the type of traversal to be
-   * performed on the subtree. It can have two possible values:
-   * @param [includeNull=false] - The `includeNull` parameter is a boolean value that determines
-   * whether to include null values in the traversal. If `includeNull` is set to `true`, the
-   * traversal will include null values, otherwise it will skip them.
-   * @returns The function `subTreeTraverse` returns an array of values that are the result of invoking
-   * the `callback` function on each node in the subtree. The type of the array nodes is determined
-   * by the return type of the `callback` function.
-   */
-  subTreeTraverse<C extends BTNCallback<N | null | undefined>>(
-    callback: C = this._defaultOneParamCallback as C,
-    beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
-    iterationType = this.iterationType,
-    includeNull = false
-  ): ReturnType<C>[] {
-    beginRoot = this.ensureNode(beginRoot);
-
-    const ans: (ReturnType<BTNCallback<N>> | null | undefined)[] = [];
-    if (!beginRoot) return ans;
-
-    if (iterationType === IterationType.RECURSIVE) {
-      const _traverse = (cur: N | null | undefined) => {
-        if (cur !== undefined) {
-          ans.push(callback(cur));
-          if (includeNull) {
-            cur && this.isNodeOrNull(cur.left) && _traverse(cur.left);
-            cur && this.isNodeOrNull(cur.right) && _traverse(cur.right);
-          } else {
-            cur && cur.left && _traverse(cur.left);
-            cur && cur.right && _traverse(cur.right);
-          }
-        }
-      };
-
-      _traverse(beginRoot);
-    } else {
-      const stack: (N | null | undefined)[] = [beginRoot];
-
-      while (stack.length > 0) {
-        const cur = stack.pop();
-        if (cur !== undefined) {
-          ans.push(callback(cur));
-          if (includeNull) {
-            cur && this.isNodeOrNull(cur.right) && stack.push(cur.right);
-            cur && this.isNodeOrNull(cur.left) && stack.push(cur.left);
-          } else {
-            cur && cur.right && stack.push(cur.right);
-            cur && cur.left && stack.push(cur.left);
-          }
-        }
-      }
-    }
-    return ans;
-  }
+  // /**
+  //  * Time complexity: O(n)
+  //  * Space complexity: O(log n)
+  //  */
+  //
+  // subTreeTraverse<C extends BTNCallback<N>>(
+  //   callback?: C,
+  //   beginRoot?: KeyOrNodeOrEntry<K, V, N>,
+  //   iterationType?: IterationType,
+  //   includeNull?: false
+  // ): ReturnType<C>[];
+  //
+  // subTreeTraverse<C extends BTNCallback<N | null>>(
+  //   callback?: C,
+  //   beginRoot?: KeyOrNodeOrEntry<K, V, N>,
+  //   iterationType?: IterationType,
+  //   includeNull?: true
+  // ): ReturnType<C>[];
+  //
+  // /**
+  //  * Time complexity: O(n)
+  //  * Space complexity: O(log n)
+  //  *
+  //  * The function `subTreeTraverse` traverses a binary tree and applies a callback function to each
+  //  * node, either recursively or iteratively.
+  //  * @param {C} callback - The `callback` parameter is a function that will be called for each node in
+  //  * the subtree traversal. It takes a single parameter, which is the current node being traversed, and
+  //  * returns a value of any type.
+  //  * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+  //  * starting node or key from which the subtree traversal should begin. It can be of type `K`,
+  //  * `N`, `null`, or `undefined`. If not provided, the `root` property of the current object is used as
+  //  * the default value.
+  //  * @param iterationType - The `iterationType` parameter determines the type of traversal to be
+  //  * performed on the subtree. It can have two possible values:
+  //  * @param [includeNull=false] - The `includeNull` parameter is a boolean value that determines
+  //  * whether to include null values in the traversal. If `includeNull` is set to `true`, the
+  //  * traversal will include null values, otherwise it will skip them.
+  //  * @returns The function `subTreeTraverse` returns an array of values that are the result of invoking
+  //  * the `callback` function on each node in the subtree. The type of the array nodes is determined
+  //  * by the return type of the `callback` function.
+  //  */
+  // subTreeTraverse<C extends BTNCallback<N | null | undefined>>(
+  //   callback: C = this._defaultOneParamCallback as C,
+  //   beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
+  //   iterationType = this.iterationType,
+  //   includeNull = false
+  // ): ReturnType<C>[] {
+  //   console.warn('subTreeTraverse is unnecessary, since the dfs method can substitute it.');
+  //
+  //   beginRoot = this.ensureNode(beginRoot);
+  //
+  //   const ans: (ReturnType<BTNCallback<N>> | null | undefined)[] = [];
+  //   if (!beginRoot) return ans;
+  //
+  //   if (iterationType === IterationType.RECURSIVE) {
+  //     const _traverse = (cur: N | null | undefined) => {
+  //       if (cur !== undefined) {
+  //         ans.push(callback(cur));
+  //         if (includeNull) {
+  //           cur && this.isNodeOrNull(cur.left) && _traverse(cur.left);
+  //           cur && this.isNodeOrNull(cur.right) && _traverse(cur.right);
+  //         } else {
+  //           cur && cur.left && _traverse(cur.left);
+  //           cur && cur.right && _traverse(cur.right);
+  //         }
+  //       }
+  //     };
+  //
+  //     _traverse(beginRoot);
+  //   } else {
+  //     const stack: (N | null | undefined)[] = [beginRoot];
+  //
+  //     while (stack.length > 0) {
+  //       const cur = stack.pop();
+  //       if (cur !== undefined) {
+  //         ans.push(callback(cur));
+  //         if (includeNull) {
+  //           cur && this.isNodeOrNull(cur.right) && stack.push(cur.right);
+  //           cur && this.isNodeOrNull(cur.left) && stack.push(cur.left);
+  //         } else {
+  //           cur && cur.right && stack.push(cur.right);
+  //           cur && cur.left && stack.push(cur.left);
+  //         }
+  //       }
+  //     }
+  //   }
+  //   return ans;
+  // }
 
   dfs<C extends BTNCallback<N>>(
     callback?: C,
@@ -1304,15 +1289,7 @@ export class BinaryTree<
     includeNull?: false
   ): ReturnType<C>[];
 
-  dfs<C extends BTNCallback<N>>(
-    callback?: C,
-    pattern?: DFSOrderPattern,
-    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
-    iterationType?: IterationType,
-    includeNull?: undefined
-  ): ReturnType<C>[];
-
-  dfs<C extends BTNCallback<N | null | undefined>>(
+  dfs<C extends BTNCallback<N | null>>(
     callback?: C,
     pattern?: DFSOrderPattern,
     beginRoot?: KeyOrNodeOrEntry<K, V, N>,
@@ -1450,14 +1427,7 @@ export class BinaryTree<
     includeNull?: false
   ): ReturnType<C>[];
 
-  bfs<C extends BTNCallback<N>>(
-    callback?: C,
-    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
-    iterationType?: IterationType,
-    includeNull?: undefined
-  ): ReturnType<C>[];
-
-  bfs<C extends BTNCallback<N | null | undefined>>(
+  bfs<C extends BTNCallback<N | null>>(
     callback?: C,
     beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType,
@@ -1485,7 +1455,7 @@ export class BinaryTree<
    * @returns an array of values that are the result of invoking the callback function on each node in
    * the breadth-first traversal of a binary tree.
    */
-  bfs<C extends BTNCallback<N | null | undefined>>(
+  bfs<C extends BTNCallback<N | null>>(
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
     iterationType = this.iterationType,
@@ -1551,14 +1521,7 @@ export class BinaryTree<
     includeNull?: false
   ): ReturnType<C>[][];
 
-  listLevels<C extends BTNCallback<N>>(
-    callback?: C,
-    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
-    iterationType?: IterationType,
-    includeNull?: undefined
-  ): ReturnType<C>[][];
-
-  listLevels<C extends BTNCallback<N | null | undefined>>(
+  listLevels<C extends BTNCallback<N | null>>(
     callback?: C,
     beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType,
@@ -1586,7 +1549,7 @@ export class BinaryTree<
    * be excluded
    * @returns The function `listLevels` returns a two-dimensional array of type `ReturnType<C>[][]`.
    */
-  listLevels<C extends BTNCallback<N | null | undefined>>(
+  listLevels<C extends BTNCallback<N | null>>(
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
     iterationType = this.iterationType,
@@ -1597,7 +1560,7 @@ export class BinaryTree<
     if (!beginRoot) return levelsNodes;
 
     if (iterationType === IterationType.RECURSIVE) {
-      const _recursive = (node: N | null | undefined, level: number) => {
+      const _recursive = (node: N | null, level: number) => {
         if (!levelsNodes[level]) levelsNodes[level] = [];
         levelsNodes[level].push(callback(node));
         if (includeNull) {
@@ -1611,7 +1574,7 @@ export class BinaryTree<
 
       _recursive(beginRoot, 0);
     } else {
-      const stack: [N | null | undefined, number][] = [[beginRoot, 0]];
+      const stack: [N | null, number][] = [[beginRoot, 0]];
 
       while (stack.length > 0) {
         const head = stack.pop()!;