data-structure-typed 1.37.1 → 1.37.3

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

@@ -5,8 +5,8 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeNodeKey, BinaryTreeNodePropertyName, BSTComparator, BSTNodeNested, BSTOptions } from '../../types';
-import { CP } from '../../types';
+import type { BinaryTreeNodeKey, BSTComparator, BSTNodeNested, BSTOptions, MapCallback, MapCallbackReturn } from '../../types';
+import { CP, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 export declare class BSTNode<V = any, FAMILY extends BSTNode<V, FAMILY> = BSTNodeNested<V>> extends BinaryTreeNode<V, FAMILY> {
@@ -45,47 +45,50 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends Binar
      * to the binary search tree.
      * @param {N['val'][]} data - The values of tree nodes
      * @param {boolean} isBalanceAdd - If true the nodes will be balance inserted in binary search method.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies whether to use a
      * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
      */
-    addMany(keysOrNodes: (BinaryTreeNodeKey | null)[] | (N | null)[], data?: N['val'][], isBalanceAdd?: boolean): (N | null | undefined)[];
+    addMany(keysOrNodes: (BinaryTreeNodeKey | null)[] | (N | null)[], data?: N['val'][], isBalanceAdd?: boolean, iterationType?: IterationType): (N | null | undefined)[];
     /**
      * The function returns the first node in a binary tree that matches the given property name and value.
      * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeKey` or a
      * generic type `N`. It represents the property of the binary tree node that you want to search for.
-     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
+     * @param callback  - The `callback` parameter is a function that takes a node as a parameter and returns a value.
      * specifies the property name to use for searching the binary tree nodes. If not provided, it defaults to `'key'`.
      * @returns The method is returning either a BinaryTreeNodeKey or N (generic type) or null.
      */
-    get(nodeProperty: BinaryTreeNodeKey | N, propertyName?: BinaryTreeNodePropertyName): N | null;
+    get(nodeProperty: BinaryTreeNodeKey | N, callback?: MapCallback<N>): N | null;
     /**
-     * The function returns the key of the rightmost node if the comparison between two values is less than, the key of the
-     * leftmost node if the comparison is greater than, and the key of the rightmost node otherwise.
-     * @returns The method `lastKey()` returns the key of the rightmost node in the binary tree if the comparison between
-     * the values at index 0 and 1 is less than, otherwise it returns the key of the leftmost node. If the comparison is
-     * equal, it returns the key of the rightmost node. If there are no nodes in the tree, it returns 0.
+     * lastKey returns the last key in a binary tree. If the binary tree is empty, it returns 0.
+     * @param beginRoot - The `beginRoot` parameter is an optional parameter that specifies the root node from which to begin
+     * the search for the last key.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies whether to use a recursive or iterative approach to search for the last key.
      */
-    lastKey(): BinaryTreeNodeKey;
+    lastKey(beginRoot?: N | null, iterationType?: IterationType): BinaryTreeNodeKey;
     /**
      * The function `getNodes` returns an array of nodes in a binary tree that match a given property value.
      * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeKey` or an
      * `N` type. It represents the property of the binary tree node that you want to compare with.
-     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
+     * @param callback - The `callback` parameter is a function that takes a node as a parameter and returns a value.
      * specifies the property name to use for comparison. If not provided, it defaults to `'key'`.
      * @param {boolean} [onlyOne] - The `onlyOne` parameter is an optional boolean parameter that determines whether to
      * return only one node that matches the given `nodeProperty` or all nodes that match the `nodeProperty`. If `onlyOne`
      * is set to `true`, the function will return an array with only one node (if
+     * @param beginRoot - The `beginRoot` parameter is an optional parameter that specifies the root node from which to
+     * @param iterationType
      * @returns an array of nodes (type N).
      */
-    getNodes(nodeProperty: BinaryTreeNodeKey | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
+    getNodes(nodeProperty: BinaryTreeNodeKey | N, callback?: MapCallback<N>, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
     /**
-     * The `lesserOrGreaterForeach` function adds a delta value to the specified property of all nodes in a binary tree that
+     * The `lesserOrGreaterTraverse` function adds a delta value to the specified property of all nodes in a binary tree that
      * have a greater value than a given node.
-     * @param {N | BinaryTreeNodeKey | null} node - The `node` parameter can be either of type `N` (a generic type), `BinaryTreeNodeKey`, or `null`. It
+     * @param callback - The `callback` parameter is a function that takes a node as a parameter and returns a value.
      * 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
+     * @param targetNode - The `targetNode` parameter is an optional parameter that specifies the node in the binary tree
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies whether to use a
      */
-    lesserOrGreaterForeach(node: N | BinaryTreeNodeKey | null, lesserOrGreater: CP | undefined, callback: (node: N) => void): boolean;
+    lesserOrGreaterTraverse(callback?: MapCallback<N>, lesserOrGreater?: CP, targetNode?: N | BinaryTreeNodeKey | null, iterationType?: IterationType): MapCallbackReturn<N>;
     /**
      * 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.
@@ -100,12 +103,12 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends Binar
      * constructs a balanced binary search tree using either a recursive or iterative approach.
      * @returns The function `perfectlyBalance()` returns a boolean value.
      */
-    perfectlyBalance(): boolean;
+    perfectlyBalance(iterationType?: IterationType): boolean;
     /**
      * The function `isAVLBalanced` checks if a binary tree is balanced according to the AVL tree property.
      * @returns a boolean value.
      */
-    isAVLBalanced(): boolean;
+    isAVLBalanced(iterationType?: IterationType): boolean;
     protected _comparator: BSTComparator;
     /**
      * The function compares two binary tree node IDs using a comparator function and returns whether the first ID is

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

@@ -1,4 +1,4 @@
-import { CP, LoopType } from '../../types';
+import { CP, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { Queue } from '../queue';
 export class BSTNode extends BinaryTreeNode {
@@ -124,9 +124,10 @@ export class BST extends BinaryTree {
      * to the binary search tree.
      * @param {N['val'][]} data - The values of tree nodes
      * @param {boolean} isBalanceAdd - If true the nodes will be balance inserted in binary search method.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies whether to use a
      * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
      */
-    addMany(keysOrNodes, data, isBalanceAdd = true) {
+    addMany(keysOrNodes, data, isBalanceAdd = true, iterationType = this.iterationType) {
         // TODO this addMany function is inefficient, it should be optimized
         function hasNoNull(arr) {
             return arr.indexOf(null) === -1;
@@ -187,7 +188,7 @@ export class BST extends BinaryTree {
                 }
             }
         };
-        if (this.loopType === LoopType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             recursive(sortedKeysOrNodes, sortedData);
         }
         else {
@@ -199,52 +200,58 @@ export class BST extends BinaryTree {
      * The function returns the first node in a binary tree that matches the given property name and value.
      * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeKey` or a
      * generic type `N`. It represents the property of the binary tree node that you want to search for.
-     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
+     * @param callback  - The `callback` parameter is a function that takes a node as a parameter and returns a value.
      * specifies the property name to use for searching the binary tree nodes. If not provided, it defaults to `'key'`.
      * @returns The method is returning either a BinaryTreeNodeKey or N (generic type) or null.
      */
-    get(nodeProperty, propertyName = 'key') {
+    get(nodeProperty, callback = this._defaultCallbackByKey) {
         var _a;
-        return (_a = this.getNodes(nodeProperty, propertyName, true)[0]) !== null && _a !== void 0 ? _a : null;
+        return (_a = this.getNodes(nodeProperty, callback, true)[0]) !== null && _a !== void 0 ? _a : null;
     }
     /**
-     * The function returns the key of the rightmost node if the comparison between two values is less than, the key of the
-     * leftmost node if the comparison is greater than, and the key of the rightmost node otherwise.
-     * @returns The method `lastKey()` returns the key of the rightmost node in the binary tree if the comparison between
-     * the values at index 0 and 1 is less than, otherwise it returns the key of the leftmost node. If the comparison is
-     * equal, it returns the key of the rightmost node. If there are no nodes in the tree, it returns 0.
+     * lastKey returns the last key in a binary tree. If the binary tree is empty, it returns 0.
+     * @param beginRoot - The `beginRoot` parameter is an optional parameter that specifies the root node from which to begin
+     * the search for the last key.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies whether to use a recursive or iterative approach to search for the last key.
      */
-    lastKey() {
+    lastKey(beginRoot = this.root, iterationType = this.iterationType) {
         var _a, _b, _c, _d, _e, _f;
         if (this._compare(0, 1) === CP.lt)
-            return (_b = (_a = this.getRightMost()) === null || _a === void 0 ? void 0 : _a.key) !== null && _b !== void 0 ? _b : 0;
+            return (_b = (_a = this.getRightMost(beginRoot, iterationType)) === null || _a === void 0 ? void 0 : _a.key) !== null && _b !== void 0 ? _b : 0;
         else if (this._compare(0, 1) === CP.gt)
-            return (_d = (_c = this.getLeftMost()) === null || _c === void 0 ? void 0 : _c.key) !== null && _d !== void 0 ? _d : 0;
+            return (_d = (_c = this.getLeftMost(beginRoot, iterationType)) === null || _c === void 0 ? void 0 : _c.key) !== null && _d !== void 0 ? _d : 0;
         else
-            return (_f = (_e = this.getRightMost()) === null || _e === void 0 ? void 0 : _e.key) !== null && _f !== void 0 ? _f : 0;
+            return (_f = (_e = this.getRightMost(beginRoot, iterationType)) === null || _e === void 0 ? void 0 : _e.key) !== null && _f !== void 0 ? _f : 0;
     }
     /**
      * The function `getNodes` returns an array of nodes in a binary tree that match a given property value.
      * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeKey` or an
      * `N` type. It represents the property of the binary tree node that you want to compare with.
-     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
+     * @param callback - The `callback` parameter is a function that takes a node as a parameter and returns a value.
      * specifies the property name to use for comparison. If not provided, it defaults to `'key'`.
      * @param {boolean} [onlyOne] - The `onlyOne` parameter is an optional boolean parameter that determines whether to
      * return only one node that matches the given `nodeProperty` or all nodes that match the `nodeProperty`. If `onlyOne`
      * is set to `true`, the function will return an array with only one node (if
+     * @param beginRoot - The `beginRoot` parameter is an optional parameter that specifies the root node from which to
+     * @param iterationType
      * @returns an array of nodes (type N).
      */
-    getNodes(nodeProperty, propertyName = 'key', onlyOne = false) {
-        if (!this.root)
+    getNodes(nodeProperty, callback = this._defaultCallbackByKey, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
+        if (!beginRoot)
             return [];
-        const result = [];
-        if (this.loopType === LoopType.RECURSIVE) {
+        const ans = [];
+        if (iterationType === IterationType.RECURSIVE) {
             const _traverse = (cur) => {
-                if (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
-                    return;
+                const callbackResult = callback(cur);
+                if (callbackResult === nodeProperty) {
+                    ans.push(cur);
+                    if (onlyOne)
+                        return;
+                }
                 if (!cur.left && !cur.right)
                     return;
-                if (propertyName === 'key') {
+                // TODO potential bug
+                if (callback === this._defaultCallbackByKey) {
                     if (this._compare(cur.key, nodeProperty) === CP.gt)
                         cur.left && _traverse(cur.left);
                     if (this._compare(cur.key, nodeProperty) === CP.lt)
@@ -255,16 +262,21 @@ export class BST extends BinaryTree {
                     cur.right && _traverse(cur.right);
                 }
             };
-            _traverse(this.root);
+            _traverse(beginRoot);
         }
         else {
-            const queue = new Queue([this.root]);
+            const queue = new Queue([beginRoot]);
             while (queue.size > 0) {
                 const cur = queue.shift();
                 if (cur) {
-                    if (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
-                        return result;
-                    if (propertyName === 'key') {
+                    const callbackResult = callback(cur);
+                    if (callbackResult === nodeProperty) {
+                        ans.push(cur);
+                        if (onlyOne)
+                            return ans;
+                    }
+                    // TODO potential bug
+                    if (callback === this._defaultCallbackByKey) {
                         if (this._compare(cur.key, nodeProperty) === CP.gt)
                             cur.left && queue.push(cur.left);
                         if (this._compare(cur.key, nodeProperty) === CP.lt)
@@ -277,55 +289,57 @@ export class BST extends BinaryTree {
                 }
             }
         }
-        return result;
+        return ans;
     }
     // --- start additional functions
     /**
-     * The `lesserOrGreaterForeach` function adds a delta value to the specified property of all nodes in a binary tree that
+     * The `lesserOrGreaterTraverse` function adds a delta value to the specified property of all nodes in a binary tree that
      * have a greater value than a given node.
-     * @param {N | BinaryTreeNodeKey | null} node - The `node` parameter can be either of type `N` (a generic type), `BinaryTreeNodeKey`, or `null`. It
+     * @param callback - The `callback` parameter is a function that takes a node as a parameter and returns a value.
      * 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
+     * @param targetNode - The `targetNode` parameter is an optional parameter that specifies the node in the binary tree
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies whether to use a
      */
-    lesserOrGreaterForeach(node, lesserOrGreater = CP.lt, callback) {
-        if (typeof node === 'number')
-            node = this.get(node, 'key');
-        if (!node)
-            return false;
-        const key = node.key;
+    lesserOrGreaterTraverse(callback = this._defaultCallbackByKey, lesserOrGreater = CP.lt, targetNode = this.root, iterationType = this.iterationType) {
+        if (typeof targetNode === 'number')
+            targetNode = this.get(targetNode);
+        const ans = [];
+        if (!targetNode)
+            return ans;
+        const targetKey = targetNode.key;
         if (!this.root)
-            return false;
-        if (this.loopType === LoopType.RECURSIVE) {
+            return ans;
+        if (iterationType === IterationType.RECURSIVE) {
             const _traverse = (cur) => {
-                const compared = this._compare(cur.key, key);
+                const compared = this._compare(cur.key, targetKey);
                 if (compared === lesserOrGreater)
-                    callback(cur);
+                    ans.push(callback(cur));
                 if (!cur.left && !cur.right)
                     return;
-                if (cur.left && this._compare(cur.left.key, key) === lesserOrGreater)
+                if (cur.left && this._compare(cur.left.key, targetKey) === lesserOrGreater)
                     _traverse(cur.left);
-                if (cur.right && this._compare(cur.right.key, key) === lesserOrGreater)
+                if (cur.right && this._compare(cur.right.key, targetKey) === lesserOrGreater)
                     _traverse(cur.right);
             };
             _traverse(this.root);
-            return true;
+            return ans;
         }
         else {
             const queue = new Queue([this.root]);
             while (queue.size > 0) {
                 const cur = queue.shift();
                 if (cur) {
-                    const compared = this._compare(cur.key, key);
+                    const compared = this._compare(cur.key, targetKey);
                     if (compared === lesserOrGreater)
-                        callback(cur);
-                    if (cur.left && this._compare(cur.left.key, key) === lesserOrGreater)
+                        ans.push(callback(cur));
+                    if (cur.left && this._compare(cur.left.key, targetKey) === lesserOrGreater)
                         queue.push(cur.left);
-                    if (cur.right && this._compare(cur.right.key, key) === lesserOrGreater)
+                    if (cur.right && this._compare(cur.right.key, targetKey) === lesserOrGreater)
                         queue.push(cur.right);
                 }
             }
-            return true;
+            return ans;
         }
     }
     /**
@@ -342,12 +356,12 @@ export class BST extends BinaryTree {
      * constructs a balanced binary search tree using either a recursive or iterative approach.
      * @returns The function `perfectlyBalance()` returns a boolean value.
      */
-    perfectlyBalance() {
-        const sorted = this.dfs('in', 'node'), n = sorted.length;
+    perfectlyBalance(iterationType = this.iterationType) {
+        const sorted = this.dfs(node => node, 'in'), n = sorted.length;
         this.clear();
         if (sorted.length < 1)
             return false;
-        if (this.loopType === LoopType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const buildBalanceBST = (l, r) => {
                 if (l > r)
                     return;
@@ -382,12 +396,12 @@ export class BST extends BinaryTree {
      * The function `isAVLBalanced` checks if a binary tree is balanced according to the AVL tree property.
      * @returns a boolean value.
      */
-    isAVLBalanced() {
+    isAVLBalanced(iterationType = this.iterationType) {
         var _a, _b;
         if (!this.root)
             return true;
         let balanced = true;
-        if (this.loopType === LoopType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _height = (cur) => {
                 if (!cur)
                     return 0;

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, IterationType } 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> {
@@ -91,7 +91,7 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
      * constructs a balanced binary search tree using either a recursive or iterative approach.
      * @returns The function `perfectlyBalance()` returns a boolean value.
      */
-    perfectlyBalance(): boolean;
+    perfectlyBalance(iterationType?: IterationType): boolean;
     /**
      * 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.
@@ -102,40 +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 `getNodesByCount` returns an array of nodes that have a specific count property, either recursively or
-     * using a queue.
-     * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeKey` or a
-     * `N`. It represents the property of the nodes that you want to search for.
-     * @param {boolean} [onlyOne] - The `onlyOne` parameter is an optional boolean parameter that determines whether to
-     * return only one node that matches the `nodeProperty` or all nodes that match the `nodeProperty`. If `onlyOne` is set
-     * to `true`, the function will return only one node. If `onlyOne`
-     * @returns an array of nodes that match the given nodeProperty.
-     */
-    getNodesByCount(nodeProperty: BinaryTreeNodeKey | N, onlyOne?: boolean): N[];
-    /**
-     * The BFSCount function returns an array of counts from a breadth-first search of nodes.
-     * @returns The BFSCount() function returns an array of numbers, specifically the count property of each node in the
-     * bfs traversal.
-     */
-    bfsCount(): number[];
-    /**
-     * The function "listLevelsCount" takes a node and returns an array of arrays, where each inner array contains the
-     * count property of each node at that level.
-     * @param {N | null} node - The parameter `node` is of type `N | null`. This means that it can either be an instance of
-     * the class `N` or `null`.
-     * @returns a 2D array of numbers. Each inner array represents a level in the binary tree, and each number in the inner
-     * array represents the count property of a node in that level.
-     */
-    listLevelsCount(node: N | null): number[][];
-    /**
-     * The `morrisCount` function returns an array of counts for each node in a binary tree, based on a specified traversal
-     * pattern.
-     * @param {'in' | 'pre' | 'post'} [pattern] - The `pattern` parameter is an optional parameter that specifies the
-     * traversal pattern for the Morris traversal algorithm. It can have one of three values: 'in', 'pre', or 'post'.
-     * @returns The function `morrisCount` returns an array of numbers.
-     */
-    morrisCount(pattern?: DFSOrderPattern): number[];
     /**
      * The clear() function clears the data and sets the count to 0.
      */

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

@@ -1,6 +1,5 @@
-import { CP, FamilyPosition, LoopType } from '../../types';
+import { CP, FamilyPosition, IterationType } 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.
@@ -221,12 +220,12 @@ export class TreeMultiset extends AVLTree {
      * constructs a balanced binary search tree using either a recursive or iterative approach.
      * @returns The function `perfectlyBalance()` returns a boolean value.
      */
-    perfectlyBalance() {
-        const sorted = this.dfs('in', 'node'), n = sorted.length;
+    perfectlyBalance(iterationType = this.iterationType) {
+        const sorted = this.dfs(node => node, 'in'), n = sorted.length;
         if (sorted.length < 1)
             return false;
         this.clear();
-        if (this.loopType === LoopType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const buildBalanceBST = (l, r) => {
                 if (l > r)
                     return;
@@ -322,83 +321,6 @@ export class TreeMultiset extends AVLTree {
         }
         return bstDeletedResult;
     }
-    /**
-     * The function `getNodesByCount` returns an array of nodes that have a specific count property, either recursively or
-     * using a queue.
-     * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeKey` or a
-     * `N`. It represents the property of the nodes that you want to search for.
-     * @param {boolean} [onlyOne] - The `onlyOne` parameter is an optional boolean parameter that determines whether to
-     * return only one node that matches the `nodeProperty` or all nodes that match the `nodeProperty`. If `onlyOne` is set
-     * to `true`, the function will return only one node. If `onlyOne`
-     * @returns an array of nodes that match the given nodeProperty.
-     */
-    getNodesByCount(nodeProperty, onlyOne = false) {
-        if (!this.root)
-            return [];
-        const result = [];
-        if (this.loopType === LoopType.RECURSIVE) {
-            const _traverse = (cur) => {
-                if (cur.count === nodeProperty) {
-                    result.push(cur);
-                    if (onlyOne)
-                        return;
-                }
-                if (!cur.left && !cur.right)
-                    return;
-                cur.left && _traverse(cur.left);
-                cur.right && _traverse(cur.right);
-            };
-            _traverse(this.root);
-        }
-        else {
-            const queue = new Queue([this.root]);
-            while (queue.size > 0) {
-                const cur = queue.shift();
-                if (cur) {
-                    if (cur.count === nodeProperty) {
-                        result.push(cur);
-                        if (onlyOne)
-                            return result;
-                    }
-                    cur.left && queue.push(cur.left);
-                    cur.right && queue.push(cur.right);
-                }
-            }
-        }
-        return result;
-    }
-    /**
-     * The BFSCount function returns an array of counts from a breadth-first search of nodes.
-     * @returns The BFSCount() function returns an array of numbers, specifically the count property of each node in the
-     * bfs traversal.
-     */
-    bfsCount() {
-        const nodes = super.bfs('node');
-        return nodes.map(node => node.count);
-    }
-    /**
-     * The function "listLevelsCount" takes a node and returns an array of arrays, where each inner array contains the
-     * count property of each node at that level.
-     * @param {N | null} node - The parameter `node` is of type `N | null`. This means that it can either be an instance of
-     * the class `N` or `null`.
-     * @returns a 2D array of numbers. Each inner array represents a level in the binary tree, and each number in the inner
-     * array represents the count property of a node in that level.
-     */
-    listLevelsCount(node) {
-        const levels = super.listLevels(node, 'node');
-        return levels.map(level => level.map(node => node.count));
-    }
-    /**
-     * The `morrisCount` function returns an array of counts for each node in a binary tree, based on a specified traversal
-     * pattern.
-     * @param {'in' | 'pre' | 'post'} [pattern] - The `pattern` parameter is an optional parameter that specifies the
-     * traversal pattern for the Morris traversal algorithm. It can have one of three values: 'in', 'pre', or 'post'.
-     * @returns The function `morrisCount` returns an array of numbers.
-     */
-    morrisCount(pattern = 'in') {
-        const nodes = super.morris(pattern, 'node');
-        return nodes.map(node => node.count);
-    }
     /**
      * The clear() function clears the data and sets the count to 0.
      */

package/lib/data-structures/heap/heap.d.ts

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

package/lib/data-structures/heap/heap.js

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

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

@@ -5,7 +5,7 @@ import { BinaryTreeNode } from '../../data-structures/binary-tree';
  * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
  * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
  */
-export declare enum LoopType {
+export declare enum IterationType {
     ITERATIVE = "ITERATIVE",
     RECURSIVE = "RECURSIVE"
 }
@@ -21,6 +21,8 @@ export declare enum FamilyPosition {
 export type BinaryTreeNodePropertyName = 'key' | 'val';
 export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
 export type BinaryTreeNodeKey = number;
+export type BFSCallback<N> = (node: N, level?: number) => any;
+export type BFSCallbackReturn<N> = ReturnType<BFSCallback<N>>;
 export type BinaryTreeNodeProperty<N extends BinaryTreeNode<N['val'], N>> = N['val'] | N | number | BinaryTreeNodeKey;
 export type BinaryTreeDeletedResult<N> = {
     deleted: N | null | undefined;
@@ -29,5 +31,5 @@ export type BinaryTreeDeletedResult<N> = {
 export type BinaryTreeNodeProperties<N extends BinaryTreeNode<N['val'], N>> = BinaryTreeNodeProperty<N>[];
 export type BinaryTreeNodeNested<T> = BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BinaryTreeOptions = {
-    loopType?: LoopType;
+    iterationType?: IterationType;
 };

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

@@ -4,11 +4,11 @@
  * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
  * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
  */
-export var LoopType;
-(function (LoopType) {
-    LoopType["ITERATIVE"] = "ITERATIVE";
-    LoopType["RECURSIVE"] = "RECURSIVE";
-})(LoopType || (LoopType = {}));
+export var IterationType;
+(function (IterationType) {
+    IterationType["ITERATIVE"] = "ITERATIVE";
+    IterationType["RECURSIVE"] = "RECURSIVE";
+})(IterationType || (IterationType = {}));
 export var FamilyPosition;
 (function (FamilyPosition) {
     FamilyPosition["ROOT"] = "ROOT";

package/lib/types/data-structures/index.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.37.1",
+  "version": "1.37.3",
   "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",
@@ -28,7 +28,7 @@
     "fix:test": "npm run lint:test && npm run format:test",
     "fix": "npm run fix:src && npm run fix:test",
     "update:individuals": "npm i avl-tree-typed binary-tree-typed bst-typed heap-typed --save-dev",
-    "install:individuals": "npm i avl-tree-typed binary-tree-typed bst-typed deque-typed directed-graph-typed doubly-linked-list-typed graph-typed heap-typed linked-list-typed max-heap-typed max-priority-queue-typed min-heap-typed min-priority-queue-typed priority-queue-typed singly-linked-list-typed stack-typed tree-multiset-typed trie-typed undirected-graph-typed queue-typed --save-dev",
+    "install:all-individuals": "npm i avl-tree-typed binary-tree-typed bst-typed deque-typed directed-graph-typed doubly-linked-list-typed graph-typed heap-typed linked-list-typed max-heap-typed max-priority-queue-typed min-heap-typed min-priority-queue-typed priority-queue-typed singly-linked-list-typed stack-typed tree-multiset-typed trie-typed undirected-graph-typed queue-typed --save-dev",
     "test": "jest",
     "check:deps": "dependency-cruiser src",
     "changelog": "auto-changelog",
@@ -58,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.9",
+    "avl-tree-typed": "^1.37.2",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.36.9",
-    "bst-typed": "^1.36.9",
+    "binary-tree-typed": "^1.37.2",
+    "bst-typed": "^1.37.2",
     "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.9",
+    "heap-typed": "^1.37.2",
     "istanbul-badges-readme": "^1.8.5",
     "jest": "^29.7.0",
     "prettier": "^3.0.3",