data-structure-typed 1.36.9 → 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.
@@ -165,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)
@@ -461,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))
@@ -664,60 +665,11 @@ export class BinaryTree {
             return size;
         }
     }
-    /**
-     * 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 `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.
      */
@@ -754,9 +706,8 @@ export class BinaryTree {
      */
     bfs(nodeOrPropertyName = 'key') {
         this._clearResults();
-        const queue = [this.root];
-        while (queue.length !== 0) {
-            // TODO Array.shift is not efficient, consider using Deque
+        const queue = new Queue([this.root]);
+        while (queue.size !== 0) {
             const cur = queue.shift();
             if (cur) {
                 this._accumulatedByPropertyName(cur, nodeOrPropertyName);

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);
                 }
             }

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

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { BinaryTreeNodeKey, TreeMultisetNodeNested, TreeMultisetOptions } from '../../types';
-import { BinaryTreeDeletedResult, DFSOrderPattern, LoopType } from '../../types';
+import { BinaryTreeDeletedResult, DFSOrderPattern } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class TreeMultisetNode<V = any, FAMILY extends TreeMultisetNode<V, FAMILY> = TreeMultisetNodeNested<V>> extends AVLTreeNode<V, FAMILY> {
@@ -102,34 +102,6 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
      * @returns The function `delete` returns an array of `BinaryTreeDeletedResult<N>` objects.
      */
     delete(nodeOrKey: N | BinaryTreeNodeKey, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
-    /**
-     * 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): [number, number];
-    /**
-     * 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;
-    /**
-     * 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;
     /**
      * The function `getNodesByCount` returns an array of nodes that have a specific count property, either recursively or
      * using a queue.
@@ -164,32 +136,6 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
      * @returns The function `morrisCount` returns an array of numbers.
      */
     morrisCount(pattern?: DFSOrderPattern): number[];
-    /**
-     * 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, loopType?: LoopType): number[];
-    /**
-     * 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;
-    /**
-     * 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;
     /**
      * The clear() function clears the data and sets the count to 0.
      */