data-structure-typed 1.36.8 → 1.36.9

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

@@ -21,13 +21,13 @@ export declare class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> e
      */
     constructor(options?: AVLTreeOptions);
     /**
-     * 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: N, destNode: N): N;
+    protected _swap(srcNode: N, destNode: N): N;
     /**
      * The function creates a new AVL tree node with the given key and value.
      * @param {BinaryTreeNodeKey} key - The `key` parameter is the identifier for the binary tree node. It is used to uniquely
@@ -46,13 +46,13 @@ export declare class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> e
      */
     add(key: BinaryTreeNodeKey, val?: N['val']): N | null | undefined;
     /**
-     * The function overrides the remove method of a binary tree and performs additional operations to balance the tree after
+     * The function overrides the delete method of a binary tree and performs additional operations to balance the tree after
      * deletion.
      * @param {BinaryTreeNodeKey} key - The `key` parameter represents the identifier of the binary tree node that needs to be
      * removed.
      * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
      */
-    remove(key: BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[];
+    delete(key: BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[];
     /**
      * The balance factor of a given AVL tree node is calculated by subtracting the height of its left subtree from the
      * height of its right subtree.

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

@@ -23,13 +23,13 @@ export class AVLTree extends BST {
         super(options);
     }
     /**
-     * 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, height } = destNode;
         const tempNode = this.createNode(key, val);
         if (tempNode) {
@@ -69,14 +69,14 @@ export class AVLTree extends BST {
         return inserted;
     }
     /**
-     * The function overrides the remove method of a binary tree and performs additional operations to balance the tree after
+     * The function overrides the delete method of a binary tree and performs additional operations to balance the tree after
      * deletion.
      * @param {BinaryTreeNodeKey} key - The `key` parameter represents the identifier of the binary tree node that needs to be
      * removed.
      * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
      */
-    remove(key) {
-        const deletedResults = super.remove(key);
+    delete(key) {
+        const deletedResults = super.delete(key);
         for (const { needBalanced } of deletedResults) {
             if (needBalanced) {
                 this._balancePath(needBalanced);

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

@@ -55,17 +55,18 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
     get size(): number;
     private _loopType;
     get loopType(): LoopType;
+    set loopType(v: LoopType);
     visitedKey: BinaryTreeNodeKey[];
     visitedVal: N['val'][];
     visitedNode: N[];
     /**
-     * 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: N, destNode: N): N;
+    protected _swap(srcNode: N, destNode: N): N;
     /**
      * The clear() function resets the root, size, and maxKey properties to their initial values.
      */
@@ -111,13 +112,13 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      */
     refill(keysOrNodes: (BinaryTreeNodeKey | null)[] | (N | null)[], data?: N[] | Array<N['val']>): boolean;
     /**
-     * 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: N | BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[];
+    delete(nodeOrKey: N | BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[];
     /**
      * The function calculates the depth of a node in a binary tree.
      * @param {N | BinaryTreeNodeKey | null} distNode - The `distNode` parameter can be any node of the tree
@@ -236,10 +237,10 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
     getRightMost(beginRoot: N): N;
     /**
      * 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: N | null): boolean;
+    isSubtreeBST(subTreeRoot: N | null): boolean;
     /**
      * The function isBST checks if the binary tree is valid binary search tree.
      * @returns The `isBST()` function is returning a boolean value.
@@ -263,16 +264,14 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      */
     subTreeSum(subTreeRoot: N | BinaryTreeNodeKey | null, propertyName?: BinaryTreeNodePropertyName): number;
     /**
-     * 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 number.
      * 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: N | BinaryTreeNodeKey | null, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
+    subTreeForeach(subTreeRoot: N | BinaryTreeNodeKey | null, callback: (node: N) => any): boolean;
     /**
      * Performs a breadth-first search (bfs) on a binary tree, accumulating properties of each node based on their 'key' property.
      * @returns An array of binary tree node IDs.
@@ -311,87 +310,26 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * Performs a depth-first search (dfs) traversal on a binary tree and accumulates properties of each node based on the specified property name.
      * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
      * @param {string} nodeOrPropertyName - The name of the property to accumulate.
+     * @param loopType - The type of loop to use for the depth-first search traversal. The default value is `LoopType.ITERATIVE`.
      * @returns An array of values corresponding to the specified property.
      */
-    dfs(pattern: DFSOrderPattern, nodeOrPropertyName: 'key'): BinaryTreeNodeKey[];
+    dfs(pattern: DFSOrderPattern, nodeOrPropertyName: 'key', loopType?: LoopType): BinaryTreeNodeKey[];
     /**
      * Performs a depth-first search (dfs) traversal on a binary tree and accumulates the 'val' property of each node.
      * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
      * @param {'val'} nodeOrPropertyName - The name of the property to accumulate.
+     * @param loopType - The type of loop to use for the depth-first search traversal. The default value is `LoopType.ITERATIVE`.
      * @returns An array of 'val' properties from each node.
      */
-    dfs(pattern: DFSOrderPattern, nodeOrPropertyName: 'val'): N[];
+    dfs(pattern: DFSOrderPattern, nodeOrPropertyName: 'val', loopType?: LoopType): N[];
     /**
      * Performs a depth-first search (dfs) traversal on a binary tree and accumulates nodes themselves.
      * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
      * @param {'node'} nodeOrPropertyName - The name of the property to accumulate.
+     * @param loopType - The type of loop to use for the depth-first search traversal. The default value is `LoopType.ITERATIVE`.
      * @returns An array of binary tree nodes.
      */
-    dfs(pattern: DFSOrderPattern, nodeOrPropertyName: 'node'): N[];
-    /**
-     * Performs an iterative depth-first search (dfs) traversal on a binary tree and accumulates properties of each node based on their 'key' property.
-     * @returns An array of binary tree node IDs.
-     */
-    dfsIterative(): BinaryTreeNodeKey[];
-    /**
-     * Performs an iterative depth-first search (dfs) traversal on a binary tree and accumulates properties of each node based on their 'key' property.
-     * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
-     * @returns An array of values corresponding to the specified property.
-     */
-    dfsIterative(pattern: DFSOrderPattern): BinaryTreeNodeKey[];
-    /**
-     * Performs an iterative depth-first search (dfs) traversal on a binary tree and accumulates properties of each node based on the specified property name.
-     * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
-     * @param {string} nodeOrPropertyName - The name of the property to accumulate.
-     * @returns An array of values corresponding to the specified property.
-     */
-    dfsIterative(pattern: DFSOrderPattern, nodeOrPropertyName: 'key'): BinaryTreeNodeKey[];
-    /**
-     * Performs an iterative depth-first search (dfs) traversal on a binary tree and accumulates the 'val' property of each node.
-     * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
-     * @param {'val'} nodeOrPropertyName - The name of the property to accumulate.
-     * @returns An array of 'val' properties from each node.
-     */
-    dfsIterative(pattern: DFSOrderPattern, nodeOrPropertyName: 'val'): N['val'][];
-    /**
-     * Performs an iterative depth-first search (dfs) traversal on a binary tree and accumulates nodes themselves.
-     * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
-     * @param {'node'} nodeOrPropertyName - The name of the property to accumulate.
-     * @returns An array of binary tree nodes.
-     */
-    dfsIterative(pattern: DFSOrderPattern, nodeOrPropertyName: 'node'): N[];
-    /**
-     * Performs a level-order traversal on a binary tree starting from the specified node and accumulates properties of each node based on their 'key' property.
-     * @returns An array of binary tree node IDs.
-     */
-    levelIterative(): BinaryTreeNodeKey[];
-    /**
-     * Performs a level-order traversal on a binary tree starting from the specified node and accumulates properties of each node based on their 'key' property.
-     * @param {N | null} node - The starting node for the level order traversal. If null, the root node of the tree is used as the starting node.
-     * @returns An array of binary tree node IDs.
-     */
-    levelIterative(node: N | null): BinaryTreeNodeKey[];
-    /**
-     * Performs a level-order traversal on a binary tree starting from the specified node and accumulates properties of each node based on the specified property name.
-     * @param {N | null} node - The starting node for the level order traversal. If null, the root node of the tree is used as the starting node.
-     * @param {string} nodeOrPropertyName - The name of the property to accumulate.
-     * @returns An array of values corresponding to the specified property.
-     */
-    levelIterative(node: N | null, nodeOrPropertyName: 'key'): BinaryTreeNodeKey[];
-    /**
-     * Performs a level-order traversal on a binary tree starting from the specified node and accumulates the 'val' property of each node.
-     * @param {N | null} node - The starting node for the level order traversal. If null, the root node of the tree is used as the starting node.
-     * @param {'val'} nodeOrPropertyName - The name of the property to accumulate.
-     * @returns An array of 'val' properties from each node.
-     */
-    levelIterative(node: N | null, nodeOrPropertyName: 'val'): N['val'][];
-    /**
-     * Performs a level-order traversal on a binary tree starting from the specified node and accumulates nodes themselves.
-     * @param {N | null} node - The starting node for the level order traversal. If null, the root node of the tree is used as the starting node.
-     * @param {'node'} nodeOrPropertyName - The name of the property to accumulate.
-     * @returns An array of binary tree nodes.
-     */
-    levelIterative(node: N | null, nodeOrPropertyName: 'node'): N[];
+    dfs(pattern: DFSOrderPattern, nodeOrPropertyName: 'node', loopType?: LoopType): N[];
     /**
      * Collects nodes from a binary tree by a specified property and organizes them into levels.
      * @returns A 2D array of AbstractBinaryTreeNodeProperty<N> objects.
@@ -477,11 +415,6 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * undefined.
      */
     protected _addTo(newNode: N | null, parent: N): N | null | undefined;
-    /**
-     * The function sets the loop type for a protected variable.
-     * @param {LoopType} value - The value parameter is of type LoopType.
-     */
-    protected _setLoopType(value: LoopType): void;
     /**
      * 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/binary-tree.js

@@ -114,14 +114,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) {
@@ -258,13 +261,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 +296,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;
@@ -589,12 +592,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 +607,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);
@@ -711,33 +714,21 @@ export class BinaryTree {
         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 number.
      * 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 +738,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);
             }
@@ -765,6 +756,7 @@ export class BinaryTree {
         this._clearResults();
         const queue = [this.root];
         while (queue.length !== 0) {
+            // TODO Array.shift is not efficient, consider using Deque
             const cur = queue.shift();
             if (cur) {
                 this._accumulatedByPropertyName(cur, nodeOrPropertyName);
@@ -781,111 +773,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 +1045,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/tree-multiset.d.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { BinaryTreeNodeKey, TreeMultisetNodeNested, TreeMultisetOptions } from '../../types';
-import { BinaryTreeDeletedResult, DFSOrderPattern } from '../../types';
+import { BinaryTreeDeletedResult, DFSOrderPattern, LoopType } 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> {
@@ -48,12 +48,12 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
     createNode(key: BinaryTreeNodeKey, val?: N['val'], count?: number): N;
     /**
      * The function swaps the location of two nodes in a tree data structure.
-     * @param {N} srcNode - The source node that we want to swap with the destination node.
+     * @param {N} srcNode - The source node that we 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 with.
      * @returns the `destNode` after swapping its values with the `srcNode`.
      */
-    swapLocation(srcNode: N, destNode: N): N;
+    protected _swap(srcNode: N, destNode: N): N;
     /**
      * The `add` function adds a new node to a binary search tree, maintaining the tree's properties and balancing if
      * necessary.
@@ -93,15 +93,15 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
      */
     perfectlyBalance(): boolean;
     /**
-     * The `remove` function removes a node from a binary search tree and returns the deleted node along with the parent
+     * The `delete` function removes a node from a binary search tree and returns the deleted node along with the parent
      * node that needs to be balanced.
      * @param {N | BinaryTreeNodeKey | null} nodeOrKey - The `nodeOrKey` parameter can be one of the following:
      * @param {boolean} [ignoreCount] - The `ignoreCount` parameter is an optional boolean parameter that determines
      * whether to ignore the count of the node being removed. If `ignoreCount` is set to `true`, the count of the node will
      * not be taken into account when removing it. If `ignoreCount` is set to `false
-     * @returns The function `remove` returns an array of `BinaryTreeDeletedResult<N>` objects.
+     * @returns The function `delete` returns an array of `BinaryTreeDeletedResult<N>` objects.
      */
-    remove(nodeOrKey: N | BinaryTreeNodeKey, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
+    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.
@@ -146,7 +146,7 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
      * @returns The BFSCount() function returns an array of numbers, specifically the count property of each node in the
      * bfs traversal.
      */
-    BFSCount(): number[];
+    bfsCount(): number[];
     /**
      * 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.
@@ -169,18 +169,11 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
      * 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.
      */
-    dfsCountIterative(pattern?: DFSOrderPattern): number[];
-    /**
-     * The dfsCount function returns an array of counts for each node in a depth-first search traversal.
-     * @param {DFSOrderPattern} [pattern] - The pattern parameter is an optional parameter that specifies the order in which
-     * the Depth-First Search (dfs) algorithm should traverse the nodes. It can have one of the following values:
-     * @returns The dfsCount function returns an array of numbers, specifically the count property of each node in the dfs
-     * traversal.
-     */
-    dfsCount(pattern?: DFSOrderPattern): number[];
+    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.