min-heap-typed 1.38.5 → 1.38.6

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

@@ -132,7 +132,7 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
   /**
    * The `addMany` function is used to efficiently add multiple nodes to a binary search tree while
    * maintaining balance.
-   * @param {[BinaryTreeNodeKey | N, N['val']][]} arr - The `arr` parameter in the `addMany` function
+   * @param {[BinaryTreeNodeKey | N, N['val']][]} keysOrNodes - The `arr` parameter in the `addMany` function
    * represents an array of keys or nodes that need to be added to the binary search tree. It can be an
    * array of `BinaryTreeNodeKey` or `N` (which represents the node type in the binary search tree) or
    * `null
@@ -223,7 +223,7 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
   /**
    * The function returns the first node in the binary tree that matches the given node property and
    * callback.
-   * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter is used to specify the
+   * @param {ReturnType<C> | N} identifier - The `nodeProperty` parameter is used to specify the
    * property of the binary tree node that you want to search for. It can be either a specific key
    * value (`BinaryTreeNodeKey`) or a custom callback function (`MapCallback<N>`) that determines
    * whether a node matches the desired property.
@@ -238,13 +238,13 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
    * @returns either the first node that matches the given nodeProperty and callback, or null if no
    * matching node is found.
    */
-  override get<C extends MapCallback<N> = MapCallback<N, BinaryTreeNodeKey>>(
-    nodeProperty: BinaryTreeNodeKey | N,
+  override get<C extends MapCallback<N>>(
+    identifier: ReturnType<C> | N,
     callback: C = this._defaultCallbackByKey as C,
     beginRoot = this.root,
     iterationType = this.iterationType
   ): N | null {
-    return this.getNodes(nodeProperty, callback, true, beginRoot, iterationType)[0] ?? null;
+    return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? null;
   }
 
   /**
@@ -271,7 +271,7 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
   /**
    * The function `getNodes` retrieves nodes from a binary tree based on a given node property or key,
    * using either recursive or iterative traversal.
-   * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter represents the property
+   * @param {ReturnType<C> | N} identifier - The `nodeProperty` parameter represents the property
    * of the binary tree node that you want to search for. It can be either a `BinaryTreeNodeKey` or a
    * generic type `N`.
    * @param callback - The `callback` parameter is a function that takes a node as input and returns a
@@ -289,8 +289,8 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
    * traverse the binary tree. It can have one of the following values:
    * @returns an array of nodes (N[]).
    */
-  override getNodes<C extends MapCallback<N> = MapCallback<N, BinaryTreeNodeKey>>(
-    nodeProperty: BinaryTreeNodeKey | N,
+  override getNodes<C extends MapCallback<N>>(
+    identifier: ReturnType<C> | N,
     callback: C = this._defaultCallbackByKey as C,
     onlyOne = false,
     beginRoot: N | null = this.root,
@@ -302,7 +302,7 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
     if (iterationType === IterationType.RECURSIVE) {
       const _traverse = (cur: N) => {
         const callbackResult = callback(cur);
-        if (callbackResult === nodeProperty) {
+        if (callbackResult === identifier) {
           ans.push(cur);
           if (onlyOne) return;
         }
@@ -310,8 +310,8 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
         if (!cur.left && !cur.right) return;
         // TODO potential bug
         if (callback === this._defaultCallbackByKey) {
-          if (this._compare(cur.key, nodeProperty as number) === CP.gt) cur.left && _traverse(cur.left);
-          if (this._compare(cur.key, nodeProperty as number) === CP.lt) cur.right && _traverse(cur.right);
+          if (this._compare(cur.key, identifier as number) === CP.gt) cur.left && _traverse(cur.left);
+          if (this._compare(cur.key, identifier as number) === CP.lt) cur.right && _traverse(cur.right);
         } else {
           cur.left && _traverse(cur.left);
           cur.right && _traverse(cur.right);
@@ -325,14 +325,14 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
         const cur = queue.shift();
         if (cur) {
           const callbackResult = callback(cur);
-          if (callbackResult === nodeProperty) {
+          if (callbackResult === identifier) {
             ans.push(cur);
             if (onlyOne) return ans;
           }
           // TODO potential bug
           if (callback === this._defaultCallbackByKey) {
-            if (this._compare(cur.key, nodeProperty as number) === CP.gt) cur.left && queue.push(cur.left);
-            if (this._compare(cur.key, nodeProperty as number) === CP.lt) cur.right && queue.push(cur.right);
+            if (this._compare(cur.key, identifier as number) === CP.gt) cur.left && queue.push(cur.left);
+            if (this._compare(cur.key, identifier as number) === CP.lt) cur.right && queue.push(cur.right);
           } else {
             cur.left && queue.push(cur.left);
             cur.right && queue.push(cur.right);
@@ -355,7 +355,7 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
    * @param {CP} lesserOrGreater - The `lesserOrGreater` parameter is used to determine whether to
    * traverse nodes that are lesser than, greater than, or equal to the `targetNode`. It can take one
    * of the following values:
-   * @param {N | BinaryTreeNodeKey | null} targetNode - The `targetNode` parameter in the
+   * @param {BinaryTreeNodeKey | N | null} targetNode - The `targetNode` parameter in the
    * `lesserOrGreaterTraverse` function is used to specify the node from which the traversal should
    * start. It can be either a reference to a specific node (`N`), the key of a node
    * (`BinaryTreeNodeKey`), or `null` to
@@ -363,10 +363,10 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
    * done recursively or iteratively. It can have two possible values:
    * @returns The function `lesserOrGreaterTraverse` returns an array of `MapCallbackReturn<N>`.
    */
-  lesserOrGreaterTraverse<C extends MapCallback<N> = MapCallback<N, BinaryTreeNodeKey>>(
+  lesserOrGreaterTraverse<C extends MapCallback<N>>(
     callback: C = this._defaultCallbackByKey as C,
     lesserOrGreater: CP = CP.lt,
-    targetNode: N | BinaryTreeNodeKey | null = this.root,
+    targetNode: BinaryTreeNodeKey | N | null = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[] {
     if (typeof targetNode === 'number') targetNode = this.get(targetNode);

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

@@ -205,8 +205,8 @@ export class RBTree<N extends RBTreeNode<N['val'], N> = RBTreeNode> extends BST<
   //   node.right = null;
   // }
   //
-  // override delete(nodeOrKey: BinaryTreeNodeKey | N): BinaryTreeDeletedResult<N>[] {
-  //   const node = this.get(nodeOrKey);
+  // override delete(keyOrNode: BinaryTreeNodeKey | N): BinaryTreeDeletedResult<N>[] {
+  //   const node = this.get(keyOrNode);
   //   const result: BinaryTreeDeletedResult<N>[] = [{deleted: undefined, needBalanced: null}];
   //   if (!node) return result; // Node does not exist
   //

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

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type {BinaryTreeNodeKey, TreeMultisetNodeNested, TreeMultisetOptions} from '../../types';
-import {BinaryTreeDeletedResult, CP, FamilyPosition, IterationType} from '../../types';
+import {BinaryTreeDeletedResult, CP, FamilyPosition, IterationType, MapCallback} from '../../types';
 import {IBinaryTree} from '../../interfaces';
 import {AVLTree, AVLTreeNode} from './avl-tree';
 
@@ -265,20 +265,28 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
   /**
    * The `delete` function in a binary search tree deletes a node from the tree and returns the deleted
    * node along with the parent node that needs to be balanced.
-   * @param {N | BinaryTreeNodeKey} nodeOrKey - The `nodeOrKey` parameter can be either a node object
-   * (`N`) or a key value (`BinaryTreeNodeKey`). It represents the node or key that needs to be deleted
-   * from the binary tree.
+   * @param {ReturnType<C>} identifier - The `identifier` parameter is either a
+   * `BinaryTreeNodeKey` or a generic type `N`. It represents the property of the node that we are
+   * searching for. It can be a specific key value or any other property of the node.
+   * @param callback - The `callback` parameter is a function that takes a node as input and returns a
+   * value. This value is compared with the `identifier` parameter to determine if the node should be
+   * included in the result. The `callback` parameter has a default value of
+   * `this._defaultCallbackByKey`
    * @param [ignoreCount=false] - A boolean flag indicating whether to ignore the count of the node
    * being deleted. If set to true, the count of the node will not be considered and the node will be
    * deleted regardless of its count. If set to false (default), the count of the node will be
    * decremented by 1 and
    * @returns The method `delete` returns an array of `BinaryTreeDeletedResult<N>` objects.
    */
-  override delete(nodeOrKey: N | BinaryTreeNodeKey, ignoreCount = false): BinaryTreeDeletedResult<N>[] {
+  override delete<C extends MapCallback<N>>(
+    identifier: ReturnType<C>,
+    callback: C = this._defaultCallbackByKey as C,
+    ignoreCount = false
+  ): BinaryTreeDeletedResult<N>[] {
     const bstDeletedResult: BinaryTreeDeletedResult<N>[] = [];
     if (!this.root) return bstDeletedResult;
 
-    const curr: N | null = this.get(nodeOrKey);
+    const curr: N | null = this.get(identifier, callback);
     if (!curr) return bstDeletedResult;
 
     const parent: N | null = curr?.parent ? curr.parent : null;

package/src/data-structures/linked-list/doubly-linked-list.ts

@@ -594,7 +594,6 @@ export class DoublyLinkedList<E = any> {
     return false;
   }
 
-
   /**
    * The `insertBefore` function inserts a new value before an existing value or node in a doubly linked list.
    * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list

package/src/interfaces/binary-tree.ts

@@ -1,10 +1,10 @@
 import {BinaryTreeNode} from '../data-structures';
-import {BinaryTreeDeletedResult, BinaryTreeNodeKey} from '../types';
+import {BinaryTreeDeletedResult, BinaryTreeNodeKey, MapCallback} from '../types';
 
 export interface IBinaryTree<N extends BinaryTreeNode<N['val'], N>> {
   createNode(key: BinaryTreeNodeKey, val?: N['val']): N;
 
   add(keyOrNode: BinaryTreeNodeKey | N | null, val?: N['val']): N | null | undefined;
 
-  delete(nodeOrKey: N | BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[];
+  delete<C extends MapCallback<N>>(identifier: ReturnType<C> | N, callback: C): BinaryTreeDeletedResult<N>[];
 }

package/src/types/helpers.ts

@@ -1,9 +1,13 @@
+import {BinaryTreeNodeKey} from './data-structures';
+
 export type Comparator<T> = (a: T, b: T) => number;
 
 export type DFSOrderPattern = 'pre' | 'in' | 'post';
 
 export type MapCallback<N, D = any> = (node: N) => D;
 
+export type DefaultMapCallback<N, D = BinaryTreeNodeKey> = (node: N) => D;
+
 export type MapCallbackReturn<N> = ReturnType<MapCallback<N>>;
 
 export enum CP {