data-structure-typed 1.36.8 → 1.37.0

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

@@ -7,6 +7,7 @@
  */
 import { FamilyPosition, LoopType } from '../../types';
 import { trampoline } from '../../utils';
+import { Queue } from '../queue';
 export class BinaryTreeNode {
     /**
      * The constructor function initializes a BinaryTreeNode object with a key and an optional value.
@@ -114,14 +115,17 @@ export class BinaryTree {
     get loopType() {
         return this._loopType;
     }
+    set loopType(v) {
+        this._loopType = v;
+    }
     /**
-     * The `swapLocation` function swaps the location of two nodes in a binary tree.
-     * @param {N} srcNode - The source node that you want to swap with the destination node.
+     * The `_swap` function swaps the location of two nodes in a binary tree.
+     * @param {N} srcNode - The source node that you want to _swap with the destination node.
      * @param {N} destNode - The `destNode` parameter represents the destination node where the values from `srcNode` will
      * be swapped to.
      * @returns The `destNode` is being returned.
      */
-    swapLocation(srcNode, destNode) {
+    _swap(srcNode, destNode) {
         const { key, val } = destNode;
         const tempNode = this.createNode(key, val);
         if (tempNode) {
@@ -162,8 +166,8 @@ export class BinaryTree {
      */
     add(keyOrNode, val) {
         const _bfs = (root, newNode) => {
-            const queue = [root];
-            while (queue.length > 0) {
+            const queue = new Queue([root]);
+            while (queue.size > 0) {
                 const cur = queue.shift();
                 if (cur) {
                     if (newNode && cur.key === newNode.key)
@@ -258,13 +262,13 @@ export class BinaryTree {
         return keysOrNodes.length === this.addMany(keysOrNodes, data).length;
     }
     /**
-     * The `remove` function in TypeScript is used to delete a node from a binary search tree and returns an array of objects
+     * The `delete` function in TypeScript is used to delete a node from a binary search tree and returns an array of objects
      * containing the deleted node and the node that needs to be balanced.
      * @param {N | BinaryTreeNodeKey} nodeOrKey - The `nodeOrKey` parameter can be either a node object (`N`) or a binary tree
      * node ID (`BinaryTreeNodeKey`).
-     * @returns The function `remove` returns an array of `BinaryTreeDeletedResult<N>` objects.
+     * @returns The function `delete` returns an array of `BinaryTreeDeletedResult<N>` objects.
      */
-    remove(nodeOrKey) {
+    delete(nodeOrKey) {
         const bstDeletedResult = [];
         if (!this.root)
             return bstDeletedResult;
@@ -293,7 +297,7 @@ export class BinaryTree {
             const leftSubTreeRightMost = curr.left ? this.getRightMost(curr.left) : null;
             if (leftSubTreeRightMost) {
                 const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
-                orgCurrent = this.swapLocation(curr, leftSubTreeRightMost);
+                orgCurrent = this._swap(curr, leftSubTreeRightMost);
                 if (parentOfLeftSubTreeMax) {
                     if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost)
                         parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
@@ -458,8 +462,8 @@ export class BinaryTree {
             _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 (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
@@ -589,12 +593,12 @@ export class BinaryTree {
     }
     /**
      * The function checks if a binary search tree is valid by traversing it either recursively or iteratively.
-     * @param {N | null} node - The `node` parameter represents the root node of a binary search tree (BST).
+     * @param {N | null} subTreeRoot - The `node` parameter represents the root node of a binary search tree (BST).
      * @returns a boolean value.
      */
-    isSubtreeBST(node) {
+    isSubtreeBST(subTreeRoot) {
         // TODO there is a bug
-        if (!node)
+        if (!subTreeRoot)
             return true;
         if (this._loopType === LoopType.RECURSIVE) {
             const dfs = (cur, min, max) => {
@@ -604,11 +608,11 @@ export class BinaryTree {
                     return false;
                 return dfs(cur.left, min, cur.key) && dfs(cur.right, cur.key, max);
             };
-            return dfs(node, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+            return dfs(subTreeRoot, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
         }
         else {
             const stack = [];
-            let prev = Number.MIN_SAFE_INTEGER, curr = node;
+            let prev = Number.MIN_SAFE_INTEGER, curr = subTreeRoot;
             while (curr || stack.length > 0) {
                 while (curr) {
                     stack.push(curr);
@@ -662,82 +666,21 @@ export class BinaryTree {
         }
     }
     /**
-     * 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, propertyName = 'key') {
-        if (typeof subTreeRoot === 'number')
-            subTreeRoot = this.get(subTreeRoot, 'key');
-        if (!subTreeRoot)
-            return 0;
-        let sum = 0;
-        const _sumByProperty = (cur) => {
-            let needSum;
-            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) => {
-                sum += _sumByProperty(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();
-                sum += _sumByProperty(cur);
-                cur.right && stack.push(cur.right);
-                cur.left && stack.push(cur.left);
-            }
-        }
-        return sum;
-    }
-    /**
-     * The function `subTreeAdd` adds a delta value to a specified property of each node in a subtree.
+     * 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 {number} delta - The `delta` parameter is a number that represents the amount by which the property value of
-     * each node in the subtree should be incremented.
-     * @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 of the binary tree node that should be modified. If not provided, it defaults to 'key'.
      * @returns a boolean value.
      */
-    subTreeAdd(subTreeRoot, delta, propertyName = 'key') {
+    subTreeForeach(subTreeRoot, callback) {
         if (typeof subTreeRoot === 'number')
             subTreeRoot = this.get(subTreeRoot, 'key');
         if (!subTreeRoot)
             return false;
-        const _addByProperty = (cur) => {
-            switch (propertyName) {
-                case 'key':
-                    cur.key += delta;
-                    break;
-                default:
-                    cur.key += delta;
-                    break;
-            }
-        };
         if (this._loopType === LoopType.RECURSIVE) {
             const _traverse = (cur) => {
-                _addByProperty(cur);
+                callback(cur);
                 cur.left && _traverse(cur.left);
                 cur.right && _traverse(cur.right);
             };
@@ -747,7 +690,7 @@ export class BinaryTree {
             const stack = [subTreeRoot];
             while (stack.length > 0) {
                 const cur = stack.pop();
-                _addByProperty(cur);
+                callback(cur);
                 cur.right && stack.push(cur.right);
                 cur.left && stack.push(cur.left);
             }
@@ -763,8 +706,8 @@ export class BinaryTree {
      */
     bfs(nodeOrPropertyName = 'key') {
         this._clearResults();
-        const queue = [this.root];
-        while (queue.length !== 0) {
+        const queue = new Queue([this.root]);
+        while (queue.size !== 0) {
             const cur = queue.shift();
             if (cur) {
                 this._accumulatedByPropertyName(cur, nodeOrPropertyName);
@@ -781,111 +724,74 @@ export class BinaryTree {
      * each node based on the specified pattern and property name.
      * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
      * @param {NodeOrPropertyName} [nodeOrPropertyName] - The name of a property of the nodes in the binary tree. This property will be used to accumulate values during the depth-first search traversal. If no `nodeOrPropertyName` is provided, the default value is `'key'`.
+     * @param loopType - The type of loop to use for the depth-first search traversal. The default value is `LoopType.ITERATIVE`.
      * @returns an instance of the BinaryTreeNodeProperties class, which contains the accumulated properties of the binary tree nodes based on the specified pattern and node or property name.
      */
-    dfs(pattern = 'in', nodeOrPropertyName = 'key') {
+    dfs(pattern = 'in', nodeOrPropertyName = 'key', loopType = LoopType.ITERATIVE) {
         this._clearResults();
-        const _traverse = (node) => {
-            switch (pattern) {
-                case 'in':
-                    if (node.left)
-                        _traverse(node.left);
-                    this._accumulatedByPropertyName(node, nodeOrPropertyName);
-                    if (node.right)
-                        _traverse(node.right);
-                    break;
-                case 'pre':
-                    this._accumulatedByPropertyName(node, nodeOrPropertyName);
-                    if (node.left)
-                        _traverse(node.left);
-                    if (node.right)
-                        _traverse(node.right);
-                    break;
-                case 'post':
-                    if (node.left)
-                        _traverse(node.left);
-                    if (node.right)
-                        _traverse(node.right);
-                    this._accumulatedByPropertyName(node, nodeOrPropertyName);
-                    break;
-            }
-        };
-        this.root && _traverse(this.root);
-        return this._getResultByPropertyName(nodeOrPropertyName);
-    }
-    /**
-     * The dfsIterative function performs an iterative depth-first search traversal on a binary tree, with the option to
-     * specify the traversal pattern and the property name to accumulate results by.
-     * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
-     * @param {NodeOrPropertyName} [nodeOrPropertyName] - The name of a property of the nodes in the binary tree. This property will be used to accumulate values during the depth-first search traversal. By default, it is set to `'key'`.
-     * @returns An object of type BinaryTreeNodeProperties<N>.
-     */
-    dfsIterative(pattern = 'in', nodeOrPropertyName = 'key') {
-        this._clearResults();
-        if (!this.root)
-            return this._getResultByPropertyName(nodeOrPropertyName);
-        // 0: visit, 1: print
-        const stack = [{ opt: 0, node: this.root }];
-        while (stack.length > 0) {
-            const cur = stack.pop();
-            if (!cur || !cur.node)
-                continue;
-            if (cur.opt === 1) {
-                this._accumulatedByPropertyName(cur.node, nodeOrPropertyName);
-            }
-            else {
+        if (loopType === LoopType.RECURSIVE) {
+            const _traverse = (node) => {
                 switch (pattern) {
                     case 'in':
-                        stack.push({ opt: 0, node: cur.node.right });
-                        stack.push({ opt: 1, node: cur.node });
-                        stack.push({ opt: 0, node: cur.node.left });
+                        if (node.left)
+                            _traverse(node.left);
+                        this._accumulatedByPropertyName(node, nodeOrPropertyName);
+                        if (node.right)
+                            _traverse(node.right);
                         break;
                     case 'pre':
-                        stack.push({ opt: 0, node: cur.node.right });
-                        stack.push({ opt: 0, node: cur.node.left });
-                        stack.push({ opt: 1, node: cur.node });
+                        this._accumulatedByPropertyName(node, nodeOrPropertyName);
+                        if (node.left)
+                            _traverse(node.left);
+                        if (node.right)
+                            _traverse(node.right);
                         break;
                     case 'post':
-                        stack.push({ opt: 1, node: cur.node });
-                        stack.push({ opt: 0, node: cur.node.right });
-                        stack.push({ opt: 0, node: cur.node.left });
-                        break;
-                    default:
-                        stack.push({ opt: 0, node: cur.node.right });
-                        stack.push({ opt: 1, node: cur.node });
-                        stack.push({ opt: 0, node: cur.node.left });
+                        if (node.left)
+                            _traverse(node.left);
+                        if (node.right)
+                            _traverse(node.right);
+                        this._accumulatedByPropertyName(node, nodeOrPropertyName);
                         break;
                 }
-            }
+            };
+            this.root && _traverse(this.root);
         }
-        return this._getResultByPropertyName(nodeOrPropertyName);
-    }
-    /**
-     * The `levelIterative` function performs a level-order traversal on a binary tree and returns the values of the nodes
-     * in an array, based on a specified property name.
-     * @param {N | null} node - The `node` parameter is a BinaryTreeNode object representing the starting
-     * node for the level order traversal. It can be null if no specific node is provided, in which case the root node of
-     * the tree is used as the starting node.
-     * @param {NodeOrPropertyName} [nodeOrPropertyName] - The `nodeOrPropertyName` parameter is an optional parameter that
-     * can be either a `BinaryTreeNode` property name or the string `'key'`. If a property name is provided, the function
-     * will accumulate results based on that property. If no property name is provided, the function will default to
-     * accumulating results based on the 'key' property.
-     * @returns An object of type `BinaryTreeNodeProperties<N>`.
-     */
-    levelIterative(node = this.root, nodeOrPropertyName = 'key') {
-        if (!node)
-            return [];
-        this._clearResults();
-        const queue = [node];
-        while (queue.length > 0) {
-            const cur = queue.shift();
-            if (cur) {
-                this._accumulatedByPropertyName(cur, nodeOrPropertyName);
-                if (cur.left) {
-                    queue.push(cur.left);
+        else {
+            if (!this.root)
+                return this._getResultByPropertyName(nodeOrPropertyName);
+            // 0: visit, 1: print
+            const stack = [{ opt: 0, node: this.root }];
+            while (stack.length > 0) {
+                const cur = stack.pop();
+                if (!cur || !cur.node)
+                    continue;
+                if (cur.opt === 1) {
+                    this._accumulatedByPropertyName(cur.node, nodeOrPropertyName);
                 }
-                if (cur.right) {
-                    queue.push(cur.right);
+                else {
+                    switch (pattern) {
+                        case 'in':
+                            stack.push({ opt: 0, node: cur.node.right });
+                            stack.push({ opt: 1, node: cur.node });
+                            stack.push({ opt: 0, node: cur.node.left });
+                            break;
+                        case 'pre':
+                            stack.push({ opt: 0, node: cur.node.right });
+                            stack.push({ opt: 0, node: cur.node.left });
+                            stack.push({ opt: 1, node: cur.node });
+                            break;
+                        case 'post':
+                            stack.push({ opt: 1, node: cur.node });
+                            stack.push({ opt: 0, node: cur.node.right });
+                            stack.push({ opt: 0, node: cur.node.left });
+                            break;
+                        default:
+                            stack.push({ opt: 0, node: cur.node.right });
+                            stack.push({ opt: 1, node: cur.node });
+                            stack.push({ opt: 0, node: cur.node.left });
+                            break;
+                    }
                 }
             }
         }
@@ -1090,13 +996,6 @@ export class BinaryTree {
             return;
         }
     }
-    /**
-     * The function sets the loop type for a protected variable.
-     * @param {LoopType} value - The value parameter is of type LoopType.
-     */
-    _setLoopType(value) {
-        this._loopType = value;
-    }
     /**
      * The function sets the root property of an object to a given value, and if the value is not null, it also sets the
      * parent property of the value to undefined.

package/lib/data-structures/binary-tree/bst.d.ts

@@ -78,28 +78,14 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends Binar
      */
     getNodes(nodeProperty: BinaryTreeNodeKey | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
     /**
-     * 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): number;
-    /**
-     * 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(node: N | BinaryTreeNodeKey | null, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
+    lesserOrGreaterForeach(node: N | BinaryTreeNodeKey | null, lesserOrGreater: CP | undefined, callback: (node: N) => void): boolean;
     /**
      * Balancing Adjustment:
      * Perfectly Balanced Binary Tree: Since the balance of a perfectly balanced binary tree is already fixed, no additional balancing adjustment is needed. Any insertion or deletion operation will disrupt the perfect balance, often requiring a complete reconstruction of the tree.

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

@@ -1,5 +1,6 @@
 import { CP, LoopType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
+import { Queue } from '../queue';
 export class BSTNode extends BinaryTreeNode {
     constructor(key, val) {
         super(key, val);
@@ -41,7 +42,7 @@ export class BST extends BinaryTree {
      * @returns The function `add` returns the inserted node (`inserted`) which can be of type `N`, `null`, or `undefined`.
      */
     add(keyOrNode, val) {
-        // TODO support node as a param
+        // TODO support node as a parameter
         let inserted = null;
         let newNode = null;
         if (keyOrNode instanceof BSTNode) {
@@ -125,7 +126,8 @@ export class BST extends BinaryTree {
      * @param {boolean} isBalanceAdd - If true the nodes will be balance inserted in binary search method.
      * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
      */
-    addMany(keysOrNodes, data, isBalanceAdd = false) {
+    addMany(keysOrNodes, data, isBalanceAdd = true) {
+        // TODO this addMany function is inefficient, it should be optimized
         function hasNoNull(arr) {
             return arr.indexOf(null) === -1;
         }
@@ -256,8 +258,8 @@ export class BST extends BinaryTree {
             _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 (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
@@ -279,106 +281,14 @@ export class BST extends BinaryTree {
     }
     // --- 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, propertyName = 'key') {
-        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) => {
-            let needSum;
-            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) => {
-                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 = [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(node, delta, propertyName = 'key') {
+    lesserOrGreaterForeach(node, lesserOrGreater = CP.lt, callback) {
         if (typeof node === 'number')
             node = this.get(node, 'key');
         if (!node)
@@ -386,42 +296,32 @@ export class BST extends BinaryTree {
         const key = node.key;
         if (!this.root)
             return false;
-        const _sumByPropertyName = (cur) => {
-            switch (propertyName) {
-                case 'key':
-                    cur.key += delta;
-                    break;
-                default:
-                    cur.key += delta;
-                    break;
-            }
-        };
         if (this.loopType === LoopType.RECURSIVE) {
             const _traverse = (cur) => {
                 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)
+                if (cur.left && this._compare(cur.left.key, key) === lesserOrGreater)
                     _traverse(cur.left);
-                if (cur.right && this._compare(cur.right.key, key) === CP.gt)
+                if (cur.right && this._compare(cur.right.key, key) === lesserOrGreater)
                     _traverse(cur.right);
             };
             _traverse(this.root);
             return true;
         }
         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) {
                     const compared = this._compare(cur.key, key);
-                    if (compared === CP.gt)
-                        _sumByPropertyName(cur);
-                    if (cur.left && this._compare(cur.left.key, key) === CP.gt)
+                    if (compared === lesserOrGreater)
+                        callback(cur);
+                    if (cur.left && this._compare(cur.left.key, key) === lesserOrGreater)
                         queue.push(cur.left);
-                    if (cur.right && this._compare(cur.right.key, key) === CP.gt)
+                    if (cur.right && this._compare(cur.right.key, key) === lesserOrGreater)
                         queue.push(cur.right);
                 }
             }