data-structure-typed 1.36.9 → 1.37.1

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

@@ -7,14 +7,16 @@
  */
 import type {
   BinaryTreeNodeKey,
-  BinaryTreeNodePropertyName,
   BSTComparator,
   BSTNodeNested,
-  BSTOptions
+  BSTOptions,
+  MapCallback,
+  MapCallbackReturn
 } from '../../types';
 import {CP, LoopType} from '../../types';
 import {BinaryTree, BinaryTreeNode} from './binary-tree';
 import {IBinaryTree} from '../../interfaces';
+import {Queue} from '../queue';
 
 export class BSTNode<V = any, FAMILY extends BSTNode<V, FAMILY> = BSTNodeNested<V>> extends BinaryTreeNode<V, FAMILY> {
   constructor(key: BinaryTreeNodeKey, val?: V) {
@@ -59,7 +61,7 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
    * @returns The function `add` returns the inserted node (`inserted`) which can be of type `N`, `null`, or `undefined`.
    */
   override add(keyOrNode: BinaryTreeNodeKey | N | null, val?: N['val']): N | null | undefined {
-    // TODO support node as a param
+    // TODO support node as a parameter
     let inserted: N | null = null;
     let newNode: N | null = null;
     if (keyOrNode instanceof BSTNode) {
@@ -137,8 +139,9 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
   override addMany(
     keysOrNodes: (BinaryTreeNodeKey | null)[] | (N | null)[],
     data?: N['val'][],
-    isBalanceAdd = false
+    isBalanceAdd = true
   ): (N | null | undefined)[] {
+    // TODO this addMany function is inefficient, it should be optimized
     function hasNoNull(arr: (BinaryTreeNodeKey | null)[] | (N | null)[]): arr is BinaryTreeNodeKey[] | N[] {
       return arr.indexOf(null) === -1;
     }
@@ -209,12 +212,12 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
    * The function returns the first node in a binary tree that matches the given property name and value.
    * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeKey` or a
    * generic type `N`. It represents the property of the binary tree node that you want to search for.
-   * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
+   * @param callback  - The `callback` parameter is a function that takes a node as a parameter and returns a value.
    * specifies the property name to use for searching the binary tree nodes. If not provided, it defaults to `'key'`.
    * @returns The method is returning either a BinaryTreeNodeKey or N (generic type) or null.
    */
-  override get(nodeProperty: BinaryTreeNodeKey | N, propertyName: BinaryTreeNodePropertyName = 'key'): N | null {
-    return this.getNodes(nodeProperty, propertyName, true)[0] ?? null;
+  override get(nodeProperty: BinaryTreeNodeKey | N, callback: MapCallback<N> = this._defaultCallbackByKey): N | null {
+    return this.getNodes(nodeProperty, callback, true)[0] ?? null;
   }
 
   /**
@@ -234,27 +237,34 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
    * The function `getNodes` returns an array of nodes in a binary tree that match a given property value.
    * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeKey` or an
    * `N` type. It represents the property of the binary tree node that you want to compare with.
-   * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
+   * @param callback - The `callback` parameter is a function that takes a node as a parameter and returns a value.
    * specifies the property name to use for comparison. If not provided, it defaults to `'key'`.
    * @param {boolean} [onlyOne] - The `onlyOne` parameter is an optional boolean parameter that determines whether to
    * return only one node that matches the given `nodeProperty` or all nodes that match the `nodeProperty`. If `onlyOne`
    * is set to `true`, the function will return an array with only one node (if
+   * @param beginRoot - The `beginRoot` parameter is an optional parameter that specifies the root node from which to
    * @returns an array of nodes (type N).
    */
   override getNodes(
     nodeProperty: BinaryTreeNodeKey | N,
-    propertyName: BinaryTreeNodePropertyName = 'key',
-    onlyOne = false
+    callback: MapCallback<N> = this._defaultCallbackByKey,
+    onlyOne = false,
+    beginRoot: N | null = this.root
   ): N[] {
-    if (!this.root) return [];
-    const result: N[] = [];
+    if (!beginRoot) return [];
+    const ans: N[] = [];
 
     if (this.loopType === LoopType.RECURSIVE) {
       const _traverse = (cur: N) => {
-        if (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne)) return;
+        const callbackResult = callback(cur);
+        if (callbackResult === nodeProperty) {
+          ans.push(cur);
+          if (onlyOne) return;
+        }
 
         if (!cur.left && !cur.right) return;
-        if (propertyName === 'key') {
+        // 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);
         } else {
@@ -263,14 +273,19 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
         }
       };
 
-      _traverse(this.root);
+      _traverse(beginRoot);
     } else {
-      const queue: N[] = [this.root];
-      while (queue.length > 0) {
+      const queue = new Queue<N>([beginRoot]);
+      while (queue.size > 0) {
         const cur = queue.shift();
         if (cur) {
-          if (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne)) return result;
-          if (propertyName === 'key') {
+          const callbackResult = callback(cur);
+          if (callbackResult === nodeProperty) {
+            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);
           } else {
@@ -281,140 +296,55 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
       }
     }
 
-    return result;
+    return ans;
   }
 
   // --- start additional functions
-  /**
-   * The `lesserSum` function calculates the sum of property values in a binary tree for nodes that have a property value
-   * less than a given node.
-   * @param {N | BinaryTreeNodeKey | null} beginNode - The `beginNode` parameter can be one of the following:
-   * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-   * specifies the property name to use for calculating the sum. If not provided, it defaults to `'key'`.
-   * @returns The function `lesserSum` returns a number, which represents the sum of the values of the nodes in the
-   * binary tree that have a lesser value than the specified `beginNode` based on the `propertyName`.
-   */
-  lesserSum(beginNode: N | BinaryTreeNodeKey | null, propertyName: BinaryTreeNodePropertyName = 'key'): number {
-    if (typeof beginNode === 'number') beginNode = this.get(beginNode, 'key');
-    if (!beginNode) return 0;
-    if (!this.root) return 0;
-    const key = beginNode.key;
-    const getSumByPropertyName = (cur: N) => {
-      let needSum: number;
-      switch (propertyName) {
-        case 'key':
-          needSum = cur.key;
-          break;
-        default:
-          needSum = cur.key;
-          break;
-      }
-      return needSum;
-    };
-
-    let sum = 0;
-
-    if (this.loopType === LoopType.RECURSIVE) {
-      const _traverse = (cur: N): void => {
-        const compared = this._compare(cur.key, key);
-        if (compared === CP.eq) {
-          if (cur.right) sum += this.subTreeSum(cur.right, propertyName);
-          return;
-        } else if (compared === CP.lt) {
-          if (cur.left) sum += this.subTreeSum(cur.left, propertyName);
-          sum += getSumByPropertyName(cur);
-          if (cur.right) _traverse(cur.right);
-          else return;
-        } else {
-          if (cur.left) _traverse(cur.left);
-          else return;
-        }
-      };
-
-      _traverse(this.root);
-    } else {
-      const queue: N[] = [this.root];
-      while (queue.length > 0) {
-        const cur = queue.shift();
-        if (cur) {
-          const compared = this._compare(cur.key, key);
-          if (compared === CP.eq) {
-            if (cur.right) sum += this.subTreeSum(cur.right, propertyName);
-            return sum;
-          } else if (compared === CP.lt) {
-            // todo maybe a bug
-            if (cur.left) sum += this.subTreeSum(cur.left, propertyName);
-            sum += getSumByPropertyName(cur);
-            if (cur.right) queue.push(cur.right);
-            else return sum;
-          } else {
-            if (cur.left) queue.push(cur.left);
-            else return sum;
-          }
-        }
-      }
-    }
-
-    return sum;
-  }
 
   /**
-   * The `allGreaterNodesAdd` function adds a delta value to the specified property of all nodes in a binary tree that
+   * The `lesserOrGreaterTraverse` function adds a delta value to the specified property of all nodes in a binary tree that
    * have a greater value than a given node.
-   * @param {N | BinaryTreeNodeKey | null} node - The `node` parameter can be either of type `N` (a generic type),
-   * `BinaryTreeNodeKey`, or `null`. It represents the node in the binary tree to which the delta value will be added.
-   * @param {number} delta - The `delta` parameter is a number that represents the amount by which the property value of
-   * each greater node should be increased.
-   * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-   * specifies the property name of the nodes in the binary tree that you want to update. If not provided, it defaults to
-   * 'key'.
-   * @returns a boolean value.
+   * @param callback - The `callback` parameter is a function that takes a node as a parameter and returns a value.
+   * @param {N | BinaryTreeNodeKey | null} node - The `node` parameter can be either of type `N` (a generic type), `BinaryTreeNodeKey`, or `null`. It
+   * represents the node in the binary tree to which the delta value will be added.
+   * @param lesserOrGreater - The `lesserOrGreater` parameter is an optional parameter that specifies whether the delta
    */
-  allGreaterNodesAdd(
-    node: N | BinaryTreeNodeKey | null,
-    delta: number,
-    propertyName: BinaryTreeNodePropertyName = 'key'
-  ): boolean {
-    if (typeof node === 'number') node = this.get(node, 'key');
-    if (!node) return false;
+  lesserOrGreaterTraverse(
+    callback: MapCallback<N> = this._defaultCallbackByKey,
+    lesserOrGreater: CP = CP.lt,
+    node: N | BinaryTreeNodeKey | null
+  ): MapCallbackReturn<N> {
+    if (typeof node === 'number') node = this.get(node);
+    const ans: MapCallbackReturn<N>[] = [];
+    if (!node) return [];
     const key = node.key;
     if (!this.root) return false;
 
-    const _sumByPropertyName = (cur: N) => {
-      switch (propertyName) {
-        case 'key':
-          cur.key += delta;
-          break;
-        default:
-          cur.key += delta;
-          break;
-      }
-    };
     if (this.loopType === LoopType.RECURSIVE) {
       const _traverse = (cur: N) => {
         const compared = this._compare(cur.key, key);
-        if (compared === CP.gt) _sumByPropertyName(cur);
+        if (compared === lesserOrGreater) ans.push(callback(cur));
 
         if (!cur.left && !cur.right) return;
-        if (cur.left && this._compare(cur.left.key, key) === CP.gt) _traverse(cur.left);
-        if (cur.right && this._compare(cur.right.key, key) === CP.gt) _traverse(cur.right);
+        if (cur.left && this._compare(cur.left.key, key) === lesserOrGreater) _traverse(cur.left);
+        if (cur.right && this._compare(cur.right.key, key) === lesserOrGreater) _traverse(cur.right);
       };
 
       _traverse(this.root);
       return true;
     } else {
-      const queue: N[] = [this.root];
-      while (queue.length > 0) {
+      const queue = new Queue<N>([this.root]);
+      while (queue.size > 0) {
         const cur = queue.shift();
         if (cur) {
           const compared = this._compare(cur.key, key);
-          if (compared === CP.gt) _sumByPropertyName(cur);
+          if (compared === lesserOrGreater) ans.push(callback(cur));
 
-          if (cur.left && this._compare(cur.left.key, key) === CP.gt) queue.push(cur.left);
-          if (cur.right && this._compare(cur.right.key, key) === CP.gt) queue.push(cur.right);
+          if (cur.left && this._compare(cur.left.key, key) === lesserOrGreater) queue.push(cur.left);
+          if (cur.right && this._compare(cur.right.key, key) === lesserOrGreater) queue.push(cur.right);
         }
       }
-      return true;
+      return ans;
     }
   }
 
@@ -434,7 +364,7 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
    * @returns The function `perfectlyBalance()` returns a boolean value.
    */
   perfectlyBalance(): boolean {
-    const sorted = this.dfs('in', 'node'),
+    const sorted = this.dfs(node => node, 'in'),
       n = sorted.length;
     this.clear();
 

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, DFSOrderPattern, FamilyPosition, LoopType} from '../../types';
+import {BinaryTreeDeletedResult, CP, FamilyPosition, LoopType} from '../../types';
 import {IBinaryTree} from '../../interfaces';
 import {AVLTree, AVLTreeNode} from './avl-tree';
 
@@ -247,7 +247,7 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
    * @returns The function `perfectlyBalance()` returns a boolean value.
    */
   override perfectlyBalance(): boolean {
-    const sorted = this.dfs('in', 'node'),
+    const sorted = this.dfs(node => node, 'in'),
       n = sorted.length;
     if (sorted.length < 1) return false;
 
@@ -349,316 +349,6 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
     return bstDeletedResult;
   }
 
-  /**
-   * The function `getSubTreeCount` calculates the number of nodes and the sum of their counts in a subtree, using either
-   * recursive or iterative traversal.
-   * @param {N | null | undefined} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree in a
-   * binary tree.
-   * @returns The function `getSubTreeCount` returns an array `[number, number]`.
-   */
-  getSubTreeCount(subTreeRoot: N | null | undefined) {
-    const res: [number, number] = [0, 0];
-    if (!subTreeRoot) return res;
-
-    if (this.loopType === LoopType.RECURSIVE) {
-      const _traverse = (cur: N) => {
-        res[0]++;
-        res[1] += cur.count;
-        cur.left && _traverse(cur.left);
-        cur.right && _traverse(cur.right);
-      };
-
-      _traverse(subTreeRoot);
-      return res;
-    } else {
-      const stack: N[] = [subTreeRoot];
-
-      while (stack.length > 0) {
-        const cur = stack.pop()!;
-        res[0]++;
-        res[1] += cur.count;
-        cur.right && stack.push(cur.right);
-        cur.left && stack.push(cur.left);
-      }
-
-      return res;
-    }
-  }
-
-  /**
-   * The function `subTreeSumCount` calculates the sum of the `count` property of each node in a subtree, either
-   * recursively or iteratively.
-   * @param {N | BinaryTreeNodeKey | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree
-   * in a binary tree. It can be either a `BinaryTreeNodeKey` (a unique identifier for a node in the binary tree) or
-   * `null` if the subtree is empty.
-   * @returns the sum of the count values of all nodes in the subtree rooted at `subTreeRoot`.
-   */
-  subTreeSumCount(subTreeRoot: N | BinaryTreeNodeKey | null): number {
-    if (typeof subTreeRoot === 'number') subTreeRoot = this.get(subTreeRoot, 'key');
-
-    if (!subTreeRoot) return 0;
-
-    let sum = 0;
-
-    if (this.loopType === LoopType.RECURSIVE) {
-      const _traverse = (cur: N): void => {
-        sum += cur.count;
-        cur.left && _traverse(cur.left);
-        cur.right && _traverse(cur.right);
-      };
-
-      _traverse(subTreeRoot);
-    } else {
-      const stack: N[] = [subTreeRoot];
-
-      while (stack.length > 0) {
-        const cur = stack.pop()!;
-        sum += cur.count;
-        cur.right && stack.push(cur.right);
-        cur.left && stack.push(cur.left);
-      }
-    }
-
-    return sum;
-  }
-
-  /**
-   * The function `subTreeAddCount` recursively or iteratively traverses a binary tree and adds a given delta value to
-   * the `count` property of each node.
-   * @param {N | BinaryTreeNodeKey | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree
-   * in a binary tree. It can be either a `BinaryTreeNodeKey` (a unique identifier for a node in the binary tree), a
-   * `BinaryTreeNode` object, or `null` if the subtree is empty.
-   * @param {number} delta - The delta parameter is a number that represents the amount by which the count of each node
-   * in the subtree should be increased or decreased.
-   * @returns a boolean value.
-   */
-  subTreeAddCount(subTreeRoot: N | BinaryTreeNodeKey | null, delta: number): boolean {
-    if (typeof subTreeRoot === 'number') subTreeRoot = this.get(subTreeRoot, 'key');
-
-    if (!subTreeRoot) return false;
-
-    const _addByProperty = (cur: N) => {
-      cur.count += delta;
-      this._setCount(this.count + delta);
-    };
-
-    if (this.loopType === LoopType.RECURSIVE) {
-      const _traverse = (cur: N) => {
-        _addByProperty(cur);
-        cur.left && _traverse(cur.left);
-        cur.right && _traverse(cur.right);
-      };
-
-      _traverse(subTreeRoot);
-    } else {
-      const stack: N[] = [subTreeRoot];
-
-      while (stack.length > 0) {
-        const cur = stack.pop()!;
-
-        _addByProperty(cur);
-        cur.right && stack.push(cur.right);
-        cur.left && stack.push(cur.left);
-      }
-    }
-    return true;
-  }
-
-  /**
-   * The function `getNodesByCount` returns an array of nodes that have a specific count property, either recursively or
-   * using a queue.
-   * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeKey` or a
-   * `N`. It represents the property of the nodes that you want to search for.
-   * @param {boolean} [onlyOne] - The `onlyOne` parameter is an optional boolean parameter that determines whether to
-   * return only one node that matches the `nodeProperty` or all nodes that match the `nodeProperty`. If `onlyOne` is set
-   * to `true`, the function will return only one node. If `onlyOne`
-   * @returns an array of nodes that match the given nodeProperty.
-   */
-  getNodesByCount(nodeProperty: BinaryTreeNodeKey | N, onlyOne = false): N[] {
-    if (!this.root) return [];
-    const result: N[] = [];
-
-    if (this.loopType === LoopType.RECURSIVE) {
-      const _traverse = (cur: N) => {
-        if (cur.count === nodeProperty) {
-          result.push(cur);
-          if (onlyOne) return;
-        }
-
-        if (!cur.left && !cur.right) return;
-        cur.left && _traverse(cur.left);
-        cur.right && _traverse(cur.right);
-      };
-
-      _traverse(this.root);
-    } else {
-      const queue: N[] = [this.root];
-      while (queue.length > 0) {
-        const cur = queue.shift();
-        if (cur) {
-          if (cur.count === nodeProperty) {
-            result.push(cur);
-            if (onlyOne) return result;
-          }
-
-          cur.left && queue.push(cur.left);
-          cur.right && queue.push(cur.right);
-        }
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * The BFSCount function returns an array of counts from a breadth-first search of nodes.
-   * @returns The BFSCount() function returns an array of numbers, specifically the count property of each node in the
-   * bfs traversal.
-   */
-  bfsCount(): number[] {
-    const nodes = super.bfs('node');
-    return nodes.map(node => node.count);
-  }
-
-  /**
-   * The function "listLevelsCount" takes a node and returns an array of arrays, where each inner array contains the
-   * count property of each node at that level.
-   * @param {N | null} node - The parameter `node` is of type `N | null`. This means that it can either be an instance of
-   * the class `N` or `null`.
-   * @returns a 2D array of numbers. Each inner array represents a level in the binary tree, and each number in the inner
-   * array represents the count property of a node in that level.
-   */
-  listLevelsCount(node: N | null): number[][] {
-    const levels = super.listLevels(node, 'node');
-    return levels.map(level => level.map(node => node.count));
-  }
-
-  /**
-   * The `morrisCount` function returns an array of counts for each node in a binary tree, based on a specified traversal
-   * pattern.
-   * @param {'in' | 'pre' | 'post'} [pattern] - The `pattern` parameter is an optional parameter that specifies the
-   * traversal pattern for the Morris traversal algorithm. It can have one of three values: 'in', 'pre', or 'post'.
-   * @returns The function `morrisCount` returns an array of numbers.
-   */
-  morrisCount(pattern: DFSOrderPattern = 'in'): number[] {
-    const nodes = super.morris(pattern, 'node');
-    return nodes.map(node => node.count);
-  }
-
-  /**
-   * The function dfsCountIterative performs an iterative depth-first search and returns an array of node counts based on
-   * the specified traversal pattern.
-   * @param {'in' | 'pre' | 'post'} [pattern] - The pattern parameter is a string that specifies the traversal order for
-   * the Depth-First Search (dfs) algorithm. It can have three possible values: 'in', 'pre', or 'post'.
-   * @param loopType  - The loopType parameter is a string that specifies the type of loop to use when traversing the
-   * @returns The dfsCountIterative function returns an array of numbers, which represents the count property of each node
-   * in the dfs traversal.
-   */
-  dfsCount(pattern: DFSOrderPattern = 'in', loopType: LoopType = LoopType.ITERATIVE): number[] {
-    const nodes = super.dfs(pattern, 'node', loopType);
-    return nodes.map(node => node.count);
-  }
-
-  /**
-   * The `lesserSumCount` function calculates the sum of the counts of all nodes in a binary tree that have a lesser
-   * value than a given node.
-   * @param {N | BinaryTreeNodeKey | null} beginNode - The `beginNode` parameter can be one of the following:
-   * @returns the sum of the counts of nodes in the binary tree that have a lesser value than the given beginNode.
-   */
-  lesserSumCount(beginNode: N | BinaryTreeNodeKey | null): number {
-    if (typeof beginNode === 'number') beginNode = this.get(beginNode, 'key');
-    if (!beginNode) return 0;
-    if (!this.root) return 0;
-    const key = beginNode.key;
-
-    let sum = 0;
-
-    if (this.loopType === LoopType.RECURSIVE) {
-      const _traverse = (cur: N): void => {
-        const compared = this._compare(cur.key, key);
-        if (compared === CP.eq) {
-          if (cur.right) sum += this.subTreeSumCount(cur.right);
-          return;
-        } else if (compared === CP.lt) {
-          if (cur.left) sum += this.subTreeSumCount(cur.left);
-          sum += cur.count;
-          if (cur.right) _traverse(cur.right);
-          else return;
-        } else {
-          if (cur.left) _traverse(cur.left);
-          else return;
-        }
-      };
-
-      _traverse(this.root);
-    } else {
-      const queue: N[] = [this.root];
-      while (queue.length > 0) {
-        const cur = queue.shift();
-        if (cur) {
-          const compared = this._compare(cur.key, key);
-          if (compared === CP.eq) {
-            if (cur.right) sum += this.subTreeSumCount(cur.right);
-            return sum;
-          } else if (compared === CP.lt) {
-            // todo maybe a bug
-            if (cur.left) sum += this.subTreeSumCount(cur.left);
-            sum += cur.count;
-            if (cur.right) queue.push(cur.right);
-            else return sum;
-          } else {
-            if (cur.left) queue.push(cur.left);
-            else return sum;
-          }
-        }
-      }
-    }
-
-    return sum;
-  }
-
-  /**
-   * The function `allGreaterNodesAddCount` updates the count property of all nodes in a binary tree that have an ID
-   * greater than a given ID by a specified delta value.
-   * @param {N | BinaryTreeNodeKey | null} node - The `node` parameter can be one of the following:
-   * @param {number} delta - The `delta` parameter is a number that represents the amount by which the `count` property
-   * of each node should be increased.
-   * @returns a boolean value.
-   */
-  allGreaterNodesAddCount(node: N | BinaryTreeNodeKey | null, delta: number): boolean {
-    if (typeof node === 'number') node = this.get(node, 'key');
-    if (!node) return false;
-    const key = node.key;
-    if (!this.root) return false;
-
-    if (this.loopType === LoopType.RECURSIVE) {
-      const _traverse = (cur: N) => {
-        const compared = this._compare(cur.key, key);
-        if (compared === CP.gt) cur.count += delta;
-
-        if (!cur.left && !cur.right) return;
-        if (cur.left && this._compare(cur.left.key, key) === CP.gt) _traverse(cur.left);
-        if (cur.right && this._compare(cur.right.key, key) === CP.gt) _traverse(cur.right);
-      };
-
-      _traverse(this.root);
-      return true;
-    } else {
-      const queue: N[] = [this.root];
-      while (queue.length > 0) {
-        const cur = queue.shift();
-        if (cur) {
-          const compared = this._compare(cur.key, key);
-          if (compared === CP.gt) cur.count += delta;
-
-          if (cur.left && this._compare(cur.left.key, key) === CP.gt) queue.push(cur.left);
-          if (cur.right && this._compare(cur.right.key, key) === CP.gt) queue.push(cur.right);
-        }
-      }
-      return true;
-    }
-  }
-
   /**
    * The clear() function clears the data and sets the count to 0.
    */

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

@@ -9,6 +9,7 @@ import {arrayRemove, uuidV4} from '../../utils';
 import {PriorityQueue} from '../priority-queue';
 import type {DijkstraResult, VertexKey} from '../../types';
 import {IGraph} from '../../interfaces';
+import {Queue} from '../queue';
 
 export abstract class AbstractVertex<V = any> {
   /**
@@ -342,11 +343,11 @@ export abstract class AbstractGraph<
       }
 
       const visited: Map<V, boolean> = new Map();
-      const queue: V[] = [vertex1];
+      const queue = new Queue<V>([vertex1]);
       visited.set(vertex1, true);
       let cost = 0;
-      while (queue.length > 0) {
-        for (let i = 0; i < queue.length; i++) {
+      while (queue.size > 0) {
+        for (let i = 0; i < queue.size; i++) {
           const cur = queue.shift();
           if (cur === vertex2) {
             return cost;

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

@@ -172,7 +172,7 @@ export class Heap<E> {
 
   /**
    * Depth-first search (DFS) method, different traversal orders can be selected。
-   * @param order - Traversal order parameter: 'in' (in-order), 'pre' (pre-order) or 'post' (post-order).
+   * @param order - Traverse order parameter: 'in' (in-order), 'pre' (pre-order) or 'post' (post-order).
    * @returns An array containing elements traversed in the specified order.
    */
   dfs(order: DFSOrderPattern): E[] {

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

@@ -28,6 +28,10 @@ export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
 
 export type BinaryTreeNodeKey = number;
 
+export type BFSCallback<N> = (node: N, level?: number) => any;
+
+export type BFSCallbackReturn<N> = ReturnType<BFSCallback<N>>;
+
 export type BinaryTreeNodeProperty<N extends BinaryTreeNode<N['val'], N>> =
   | N['val']
   | N

package/src/types/data-structures/index.ts

@@ -12,3 +12,6 @@ export * from './singly-linked-list';
 export * from './doubly-linked-list';
 export * from './navigator';
 export * from './hash';
+
+export type MapCallback<N> = (node: N) => any;
+export type MapCallbackReturn<N> = ReturnType<MapCallback<N>>;