min-heap-typed 1.49.9 → 1.50.1

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

@@ -18,9 +18,6 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
         [key: string]: HashMapStoreItem<K, V>;
     };
     protected _objMap: Map<object, V>;
-    protected _toEntryFn: (rawElement: R) => [K, V];
-    get toEntryFn(): (rawElement: R) => [K, V];
-    isEntry(rawElement: any): rawElement is [K, V];
     /**
      * The constructor function initializes a HashMap object with an optional initial collection and
      * options.
@@ -29,8 +26,11 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * @param [options] - The `options` parameter is an optional object that can contain two properties:
      */
     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;
     /**

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

@@ -10,12 +10,6 @@ const utils_1 = require("../../utils");
  * 4. Unordered Collection: HashMap does not guarantee the order of entries, and the order may change over time.
  */
 class HashMap extends base_1.IterableEntryBase {
-    get toEntryFn() {
-        return this._toEntryFn;
-    }
-    isEntry(rawElement) {
-        return Array.isArray(rawElement) && rawElement.length === 2;
-    }
     /**
      * The constructor function initializes a HashMap object with an optional initial collection and
      * options.
@@ -51,9 +45,15 @@ class HashMap extends base_1.IterableEntryBase {
             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;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "min-heap-typed",
-  "version": "1.49.9",
+  "version": "1.50.1",
   "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.9"
+    "data-structure-typed": "^1.50.0"
   }
 }

package/src/data-structures/base/iterable-base.ts

@@ -15,7 +15,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
    * allows the function to accept any number of arguments as an array. In this case, the `args`
    * parameter is used to pass any additional arguments to the `_getIterator` method.
    */
-  *[Symbol.iterator](...args: any[]): IterableIterator<[K, V]> {
+  * [Symbol.iterator](...args: any[]): IterableIterator<[K, V]> {
     yield* this._getIterator(...args);
   }
 
@@ -30,7 +30,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
    * The function returns an iterator that yields key-value pairs from the object, where the value can
    * be undefined.
    */
-  *entries(): IterableIterator<[K, V | undefined]> {
+  * entries(): IterableIterator<[K, V | undefined]> {
     for (const item of this) {
       yield item;
     }
@@ -46,7 +46,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
    *
    * The function returns an iterator that yields the keys of a data structure.
    */
-  *keys(): IterableIterator<K> {
+  * keys(): IterableIterator<K> {
     for (const item of this) {
       yield item[0];
     }
@@ -62,7 +62,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
    *
    * The function returns an iterator that yields the values of a collection.
    */
-  *values(): IterableIterator<V> {
+  * values(): IterableIterator<V> {
     for (const item of this) {
       yield item[1];
     }
@@ -212,7 +212,7 @@ export abstract class IterableElementBase<V> {
    * allows the function to accept any number of arguments as an array. In this case, the `args`
    * parameter is used to pass any number of arguments to the `_getIterator` method.
    */
-  *[Symbol.iterator](...args: any[]): IterableIterator<V> {
+  * [Symbol.iterator](...args: any[]): IterableIterator<V> {
     yield* this._getIterator(...args);
   }
 
@@ -226,7 +226,7 @@ export abstract class IterableElementBase<V> {
    *
    * The function returns an iterator that yields all the values in the object.
    */
-  *values(): IterableIterator<V> {
+  * values(): IterableIterator<V> {
     for (const item of this) {
       yield item;
     }

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

@@ -40,14 +40,13 @@ export class AVLTreeNode<K = any, V = any, N extends AVLTreeNode<K, V, N> = AVLT
  * 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.
  */
 export class AVLTree<
-    K = any,
-    V = any,
-    N extends AVLTreeNode<K, V, N> = AVLTreeNode<K, V, AVLTreeNodeNested<K, V>>,
-    TREE extends AVLTree<K, V, N, TREE> = AVLTree<K, V, N, AVLTreeNested<K, V, N>>
-  >
+  K = any,
+  V = any,
+  N extends AVLTreeNode<K, V, N> = AVLTreeNode<K, V, AVLTreeNodeNested<K, V>>,
+  TREE extends AVLTree<K, V, N, TREE> = AVLTree<K, V, N, AVLTreeNested<K, V, N>>
+>
   extends BST<K, V, N, TREE>
-  implements IBinaryTree<K, V, N, TREE>
-{
+  implements IBinaryTree<K, V, N, TREE> {
   /**
    * The constructor function initializes an AVLTree object with optional keysOrNodesOrEntries and options.
    * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
@@ -99,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)
@@ -278,7 +267,7 @@ export class AVLTree<
       // Balance Restoration: If a balance issue is discovered after inserting a node, it requires balance restoration operations. Balance restoration includes four basic cases where rotation operations need to be performed to fix the balance:
       switch (
         this._balanceFactor(A) // second O(1)
-      ) {
+        ) {
         case -2:
           if (A && A.left) {
             if (this._balanceFactor(A.left) <= 0) {

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

@@ -101,14 +101,13 @@ export class BinaryTreeNode<
  */
 
 export class BinaryTree<
-    K = any,
-    V = any,
-    N extends BinaryTreeNode<K, V, N> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>,
-    TREE extends BinaryTree<K, V, N, TREE> = BinaryTree<K, V, N, BinaryTreeNested<K, V, N>>
-  >
+  K = any,
+  V = any,
+  N extends BinaryTreeNode<K, V, N> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>,
+  TREE extends BinaryTree<K, V, N, TREE> = BinaryTree<K, V, N, BinaryTreeNested<K, V, N>>
+>
   extends IterableEntryBase<K, V | undefined>
-  implements IBinaryTree<K, V, N, TREE>
-{
+  implements IBinaryTree<K, V, N, TREE> {
   iterationType = IterationType.ITERATIVE;
 
   /**
@@ -197,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;
@@ -293,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)
@@ -1029,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
@@ -1037,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;
   }
 
@@ -1203,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,
@@ -1305,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>,
@@ -1451,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,
@@ -1486,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,
@@ -1552,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,
@@ -1587,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,
@@ -1598,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) {
@@ -1612,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()!;
@@ -1923,7 +1885,7 @@ export class BinaryTree<
     display(beginRoot);
   }
 
-  protected *_getIterator(node = this.root): IterableIterator<[K, V | undefined]> {
+  protected* _getIterator(node = this.root): IterableIterator<[K, V | undefined]> {
     if (!node) return;
 
     if (this.iterationType === IterationType.ITERATIVE) {