data-structure-typed 1.36.9 → 1.37.0

package/lib/data-structures/binary-tree/tree-multiset.js

@@ -1,5 +1,6 @@
 import { CP, FamilyPosition, LoopType } from '../../types';
 import { AVLTree, AVLTreeNode } from './avl-tree';
+import { Queue } from '../queue';
 export class TreeMultisetNode extends AVLTreeNode {
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
@@ -321,110 +322,6 @@ export class TreeMultiset extends AVLTree {
         }
         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) {
-        const res = [0, 0];
-        if (!subTreeRoot)
-            return res;
-        if (this.loopType === LoopType.RECURSIVE) {
-            const _traverse = (cur) => {
-                res[0]++;
-                res[1] += cur.count;
-                cur.left && _traverse(cur.left);
-                cur.right && _traverse(cur.right);
-            };
-            _traverse(subTreeRoot);
-            return res;
-        }
-        else {
-            const stack = [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) {
-        if (typeof subTreeRoot === 'number')
-            subTreeRoot = this.get(subTreeRoot, 'key');
-        if (!subTreeRoot)
-            return 0;
-        let sum = 0;
-        if (this.loopType === LoopType.RECURSIVE) {
-            const _traverse = (cur) => {
-                sum += cur.count;
-                cur.left && _traverse(cur.left);
-                cur.right && _traverse(cur.right);
-            };
-            _traverse(subTreeRoot);
-        }
-        else {
-            const stack = [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, delta) {
-        if (typeof subTreeRoot === 'number')
-            subTreeRoot = this.get(subTreeRoot, 'key');
-        if (!subTreeRoot)
-            return false;
-        const _addByProperty = (cur) => {
-            cur.count += delta;
-            this._setCount(this.count + delta);
-        };
-        if (this.loopType === LoopType.RECURSIVE) {
-            const _traverse = (cur) => {
-                _addByProperty(cur);
-                cur.left && _traverse(cur.left);
-                cur.right && _traverse(cur.right);
-            };
-            _traverse(subTreeRoot);
-        }
-        else {
-            const stack = [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.
@@ -454,8 +351,8 @@ export class TreeMultiset extends AVLTree {
             _traverse(this.root);
         }
         else {
-            const queue = [this.root];
-            while (queue.length > 0) {
+            const queue = new Queue([this.root]);
+            while (queue.size > 0) {
                 const cur = queue.shift();
                 if (cur) {
                     if (cur.count === nodeProperty) {
@@ -502,140 +399,6 @@ export class TreeMultiset extends AVLTree {
         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 = 'in', loopType = LoopType.ITERATIVE) {
-        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) {
-        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) => {
-                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 = [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, delta) {
-        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) => {
-                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 = [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/lib/data-structures/graph/abstract-graph.js

@@ -7,6 +7,7 @@
  */
 import { arrayRemove, uuidV4 } from '../../utils';
 import { PriorityQueue } from '../priority-queue';
+import { Queue } from '../queue';
 export class AbstractVertex {
     /**
      * The function is a protected constructor that takes an key and an optional value as parameters.
@@ -265,11 +266,11 @@ export class AbstractGraph {
                 return null;
             }
             const visited = new Map();
-            const queue = [vertex1];
+            const queue = new Queue([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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.36.9",
+  "version": "1.37.0",
   "description": "Data Structures of Javascript & TypeScript. Binary Tree, BST, Graph, Heap, Priority Queue, Linked List, Queue, Deque, Stack, AVL Tree, Tree Multiset, Trie, Directed Graph, Undirected Graph, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue.",
   "main": "dist/index.js",
   "module": "lib/index.js",
@@ -33,8 +33,10 @@
     "check:deps": "dependency-cruiser src",
     "changelog": "auto-changelog",
     "coverage:badge": "istanbul-badges-readme",
-    "ci": "env && npm run lint && npm run build && npm run update:individuals && npm run test && git fetch --tags && npm run changelog",
-    "publish:all": "npm run ci && npm publish && sh scripts/publish_all_subs.sh && sh scripts/publish_docs.sh"
+    "ci": "env && git fetch --tags && npm run lint && npm run build && npm run update:individuals && npm run test && npm run changelog",
+    "publish:individuals": "sh scripts/publish_all_subs.sh",
+    "publish:docs": "sh scripts/publish_docs.sh",
+    "publish:all": "npm run ci && npm publish && npm run publish:individuals && npm run publish:docs"
   },
   "repository": {
     "type": "git",
@@ -56,17 +58,17 @@
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
     "auto-changelog": "^2.4.0",
-    "avl-tree-typed": "^1.36.8",
+    "avl-tree-typed": "^1.36.9",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.36.8",
-    "bst-typed": "^1.36.8",
+    "binary-tree-typed": "^1.36.9",
+    "bst-typed": "^1.36.9",
     "dependency-cruiser": "^14.1.0",
     "eslint": "^8.50.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-import-resolver-alias": "^1.1.2",
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-import": "^2.28.1",
-    "heap-typed": "^1.36.8",
+    "heap-typed": "^1.36.9",
     "istanbul-badges-readme": "^1.8.5",
     "jest": "^29.7.0",
     "prettier": "^3.0.3",

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

@@ -23,6 +23,7 @@ import {
 } from '../../types';
 import {IBinaryTree} from '../../interfaces';
 import {trampoline} from '../../utils';
+import {Queue} from '../queue';
 
 export class BinaryTreeNode<V = any, FAMILY extends BinaryTreeNode<V, FAMILY> = BinaryTreeNodeNested<V>> {
   /**
@@ -210,8 +211,8 @@ export class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode>
    */
   add(keyOrNode: BinaryTreeNodeKey | N | null, val?: N['val']): N | null | undefined {
     const _bfs = (root: N, newNode: N | null): N | undefined | null => {
-      const queue: Array<N | null> = [root];
-      while (queue.length > 0) {
+      const queue = new Queue<N | null>([root]);
+      while (queue.size > 0) {
         const cur = queue.shift();
         if (cur) {
           if (newNode && cur.key === newNode.key) return;
@@ -509,8 +510,8 @@ export class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode>
 
       _traverse(this.root);
     } 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) {
           if (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne)) return result;
@@ -762,65 +763,11 @@ export class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode>
     }
   }
 
-  /**
-   * The function `subTreeSum` calculates the sum of a specified property in a binary tree or subtree.
-   * @param {N | BinaryTreeNodeKey | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a binary
-   * tree or the ID of a binary tree node. It can also be `null` if there is no subtree.
-   * @param {BinaryTreeNodePropertyName} [propertyName] - propertyName is an optional parameter that specifies the
-   * property of the binary tree node to use for calculating the sum. It can be either 'key' or 'val'. If propertyName is
-   * not provided, it defaults to 'key'.
-   * @returns a number, which is the sum of the values of the specified property in the subtree rooted at `subTreeRoot`.
-   */
-  subTreeSum(subTreeRoot: N | BinaryTreeNodeKey | null, propertyName: BinaryTreeNodePropertyName = 'key'): number {
-    if (typeof subTreeRoot === 'number') subTreeRoot = this.get(subTreeRoot, 'key');
-
-    if (!subTreeRoot) return 0;
-
-    let sum = 0;
-
-    const _sumByProperty = (cur: N) => {
-      let needSum: number;
-      switch (propertyName) {
-        case 'key':
-          needSum = cur.key;
-          break;
-        case 'val':
-          needSum = typeof cur.val === 'number' ? cur.val : 0;
-          break;
-        default:
-          needSum = cur.key;
-          break;
-      }
-      return needSum;
-    };
-
-    if (this._loopType === LoopType.RECURSIVE) {
-      const _traverse = (cur: N): void => {
-        sum += _sumByProperty(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()!;
-        sum += _sumByProperty(cur);
-        cur.right && stack.push(cur.right);
-        cur.left && stack.push(cur.left);
-      }
-    }
-
-    return sum;
-  }
-
   /**
    * The function `subTreeForeach` adds a delta value to a specified property of each node in a subtree.
    * @param {N | BinaryTreeNodeKey | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a binary
    * tree or the ID of a node in the binary tree. It can also be `null` if there is no subtree to add to.
-   * @param callBack - The `callBack` parameter is a function that takes a node as a parameter and returns a number.
+   * @param callback - The `callback` parameter is a function that takes a node as a parameter and returns a value.
    * specifies the property of the binary tree node that should be modified. If not provided, it defaults to 'key'.
    * @returns a boolean value.
    */
@@ -887,10 +834,9 @@ export class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode>
    */
   bfs(nodeOrPropertyName: NodeOrPropertyName = 'key'): BinaryTreeNodeProperties<N> {
     this._clearResults();
-    const queue: Array<N | null | undefined> = [this.root];
+    const queue = new Queue<N | null | undefined>([this.root]);
 
-    while (queue.length !== 0) {
-      // TODO Array.shift is not efficient, consider using Deque
+    while (queue.size !== 0) {
       const cur = queue.shift();
       if (cur) {
         this._accumulatedByPropertyName(cur, nodeOrPropertyName);

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

@@ -15,6 +15,7 @@ import type {
 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 +60,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 +138,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;
     }
@@ -265,8 +267,8 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
 
       _traverse(this.root);
     } 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) {
           if (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne)) return result;
@@ -285,133 +287,47 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
   }
 
   // --- 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 `lesserOrGreaterForeach` 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 {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
+   * @param callback - The `callback` parameter is a function that takes a node as a parameter and returns a boolean
    */
-  allGreaterNodesAdd(
+  lesserOrGreaterForeach(
     node: N | BinaryTreeNodeKey | null,
-    delta: number,
-    propertyName: BinaryTreeNodePropertyName = 'key'
+    lesserOrGreater: CP = CP.lt,
+    callback: (node: N) => void
   ): boolean {
     if (typeof node === 'number') node = this.get(node, 'key');
     if (!node) return false;
     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) 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) 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;