avl-tree-typed 1.46.8 → 1.47.2

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BSTComparator, BSTNodeNested, BSTOptions, BTNCallback, BTNKey } from '../../types';
+import type { BSTNested, BSTNodeNested, BSTOptions, BTNCallback, BTNKey } from '../../types';
 import { CP, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
@@ -33,7 +33,8 @@ export declare class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>
      */
     set right(v: N | undefined);
 }
-export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>> extends BinaryTree<V, N> implements IBinaryTree<V, N> {
+export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>, TREE extends BST<V, N, TREE> = BST<V, N, BSTNested<V, N>>> extends BinaryTree<V, N, TREE> implements IBinaryTree<V, N, TREE> {
+    options: BSTOptions;
     /**
      * The constructor function initializes a binary search tree with an optional comparator function.
      * @param {BSTOptions} [options] - An optional object that contains additional configuration options
@@ -54,6 +55,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * @returns a new instance of the BSTNode class with the specified key and value.
      */
     createNode(key: BTNKey, value?: V): N;
+    createTree(options?: BSTOptions): TREE;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
      * Space Complexity: O(1) - Constant space is used.
@@ -95,7 +97,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * current instance of the binary search tree
      * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
      */
-    addMany(keysOrNodes: (BTNKey | N | undefined)[], data?: (V | undefined)[], isBalanceAdd?: boolean, iterationType?: IterationType): (N | undefined)[];
+    addMany(keysOrNodes: (BTNKey | N | undefined)[], data?: (V | undefined)[], isBalanceAdd?: boolean, iterationType?: IterationType | undefined): (N | undefined)[];
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
      * Space Complexity: O(1) - Constant space is used.
@@ -115,7 +117,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * the key of the leftmost node if the comparison result is greater than, and the key of the
      * rightmost node otherwise. If no node is found, it returns 0.
      */
-    lastKey(beginRoot?: BTNKey | N | undefined, iterationType?: IterationType): BTNKey;
+    lastKey(beginRoot?: BTNKey | N | undefined, iterationType?: IterationType | undefined): BTNKey;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -172,7 +174,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * performed on the binary tree. It can have two possible values:
      * @returns The method returns an array of nodes (`N[]`).
      */
-    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C> | undefined, callback?: C, onlyOne?: boolean, beginRoot?: BTNKey | N | undefined, iterationType?: IterationType): N[];
+    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C> | undefined, callback?: C, onlyOne?: boolean, beginRoot?: BTNKey | N | undefined, iterationType?: IterationType | undefined): N[];
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -198,7 +200,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * @returns The function `lesserOrGreaterTraverse` returns an array of values of type
      * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
      */
-    lesserOrGreaterTraverse<C extends BTNCallback<N>>(callback?: C, lesserOrGreater?: CP, targetNode?: BTNKey | N | undefined, iterationType?: IterationType): ReturnType<C>[];
+    lesserOrGreaterTraverse<C extends BTNCallback<N>>(callback?: C, lesserOrGreater?: CP, targetNode?: BTNKey | N | undefined, iterationType?: IterationType | undefined): ReturnType<C>[];
     /**
      * 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.
@@ -223,7 +225,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * values:
      * @returns The function `perfectlyBalance` returns a boolean value.
      */
-    perfectlyBalance(iterationType?: IterationType): boolean;
+    perfectlyBalance(iterationType?: IterationType | undefined): boolean;
     /**
      * Time Complexity: O(n) - Visiting each node once.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -237,8 +239,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * to check if the AVL tree is balanced. It can have two possible values:
      * @returns a boolean value.
      */
-    isAVLBalanced(iterationType?: IterationType): boolean;
-    protected _comparator: BSTComparator;
+    isAVLBalanced(iterationType?: IterationType | undefined): boolean;
     protected _setRoot(v: N | undefined): void;
     /**
      * The function compares two values using a comparator function and returns whether the first value

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

@@ -53,14 +53,13 @@ class BST extends binary_tree_1.BinaryTree {
      */
     constructor(options) {
         super(options);
-        this._comparator = (a, b) => a - b;
-        this._root = undefined;
-        if (options !== undefined) {
-            const { comparator } = options;
-            if (comparator !== undefined) {
-                this._comparator = comparator;
-            }
+        if (options) {
+            this.options = Object.assign({ iterationType: types_1.IterationType.ITERATIVE, comparator: (a, b) => a - b }, options);
+        }
+        else {
+            this.options = { iterationType: types_1.IterationType.ITERATIVE, comparator: (a, b) => a - b };
         }
+        this._root = undefined;
     }
     /**
      * Get the root node of the binary tree.
@@ -79,6 +78,9 @@ class BST extends binary_tree_1.BinaryTree {
     createNode(key, value) {
         return new BSTNode(key, value);
     }
+    createTree(options) {
+        return new BST(Object.assign(Object.assign({}, this.options), options));
+    }
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
      * Space Complexity: O(1) - Constant space is used.
@@ -196,7 +198,7 @@ class BST extends binary_tree_1.BinaryTree {
      * current instance of the binary search tree
      * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
      */
-    addMany(keysOrNodes, data, isBalanceAdd = true, iterationType = this.iterationType) {
+    addMany(keysOrNodes, data, isBalanceAdd = true, iterationType = this.options.iterationType) {
         // TODO this addMany function is inefficient, it should be optimized
         function hasNoUndefined(arr) {
             return arr.indexOf(undefined) === -1;
@@ -284,7 +286,7 @@ class BST extends binary_tree_1.BinaryTree {
      * the key of the leftmost node if the comparison result is greater than, and the key of the
      * rightmost node otherwise. If no node is found, it returns 0.
      */
-    lastKey(beginRoot = this.root, iterationType = this.iterationType) {
+    lastKey(beginRoot = this.root, iterationType = this.options.iterationType) {
         var _a, _b, _c, _d, _e, _f;
         if (this._compare(0, 1) === types_1.CP.lt)
             return (_b = (_a = this.getRightMost(beginRoot, iterationType)) === null || _a === void 0 ? void 0 : _a.key) !== null && _b !== void 0 ? _b : 0;
@@ -381,7 +383,7 @@ class BST extends binary_tree_1.BinaryTree {
      * performed on the binary tree. It can have two possible values:
      * @returns The method returns an array of nodes (`N[]`).
      */
-    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
+    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.options.iterationType) {
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return [];
@@ -462,7 +464,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns The function `lesserOrGreaterTraverse` returns an array of values of type
      * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
      */
-    lesserOrGreaterTraverse(callback = this._defaultOneParamCallback, lesserOrGreater = types_1.CP.lt, targetNode = this.root, iterationType = this.iterationType) {
+    lesserOrGreaterTraverse(callback = this._defaultOneParamCallback, lesserOrGreater = types_1.CP.lt, targetNode = this.root, iterationType = this.options.iterationType) {
         targetNode = this.ensureNotKey(targetNode);
         const ans = [];
         if (!targetNode)
@@ -526,7 +528,7 @@ class BST extends binary_tree_1.BinaryTree {
      * values:
      * @returns The function `perfectlyBalance` returns a boolean value.
      */
-    perfectlyBalance(iterationType = this.iterationType) {
+    perfectlyBalance(iterationType = this.options.iterationType) {
         const sorted = this.dfs(node => node, 'in'), n = sorted.length;
         this.clear();
         if (sorted.length < 1)
@@ -576,7 +578,7 @@ class BST extends binary_tree_1.BinaryTree {
      * to check if the AVL tree is balanced. It can have two possible values:
      * @returns a boolean value.
      */
-    isAVLBalanced(iterationType = this.iterationType) {
+    isAVLBalanced(iterationType = this.options.iterationType) {
         var _a, _b;
         if (!this.root)
             return true;
@@ -637,7 +639,7 @@ class BST extends binary_tree_1.BinaryTree {
      * than), CP.lt (less than), or CP.eq (equal).
      */
     _compare(a, b) {
-        const compared = this._comparator(a, b);
+        const compared = this.options.comparator(a, b);
         if (compared > 0)
             return types_1.CP.gt;
         else if (compared < 0)

package/dist/data-structures/binary-tree/rb-tree.d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { BiTreeDeleteResult, BTNCallback, BTNKey, IterationType, RBTNColor, RBTreeOptions, RedBlackTreeNodeNested } from '../../types';
+import { BiTreeDeleteResult, BTNCallback, BTNKey, IterationType, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 export declare class RedBlackTreeNode<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTreeNodeNested<V>> extends BSTNode<V, N> {
@@ -15,12 +15,13 @@ export declare class RedBlackTreeNode<V = any, N extends RedBlackTreeNode<V, N>
 /**
  * 1. Each node is either red or black.
  * 2. The root node is always black.
- * 3. Leaf nodes are typically NIL nodes and are considered black.
+ * 3. Leaf nodes are typically Sentinel nodes and are considered black.
  * 4. Red nodes must have black children.
  * 5. Black balance: Every path from any node to each of its leaf nodes contains the same number of black nodes.
  */
-export declare class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTreeNode<V, RedBlackTreeNodeNested<V>>> extends BST<V, N> implements IBinaryTree<V, N> {
-    NIL: N;
+export declare class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTreeNode<V, RedBlackTreeNodeNested<V>>, TREE extends RedBlackTree<V, N, TREE> = RedBlackTree<V, N, RedBlackTreeNested<V, N>>> extends BST<V, N, TREE> implements IBinaryTree<V, N, TREE> {
+    Sentinel: N;
+    options: RBTreeOptions;
     /**
      * The constructor function initializes a Red-Black Tree with an optional set of options.
      * @param {RBTreeOptions} [options] - The `options` parameter is an optional object that can be
@@ -31,6 +32,8 @@ export declare class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = Re
     get root(): N;
     protected _size: number;
     get size(): number;
+    createNode(key: BTNKey, value?: V, color?: RBTNColor): N;
+    createTree(options?: RBTreeOptions): TREE;
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)
@@ -47,7 +50,6 @@ export declare class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = Re
      * @returns The method returns either a node (`N`) or `undefined`.
      */
     add(keyOrNode: BTNKey | N | null | undefined, value?: V): N | undefined;
-    createNode(key: BTNKey, value?: V, color?: RBTNColor): N;
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)

package/dist/data-structures/binary-tree/rb-tree.js

@@ -21,7 +21,7 @@ exports.RedBlackTreeNode = RedBlackTreeNode;
 /**
  * 1. Each node is either red or black.
  * 2. The root node is always black.
- * 3. Leaf nodes are typically NIL nodes and are considered black.
+ * 3. Leaf nodes are typically Sentinel nodes and are considered black.
  * 4. Red nodes must have black children.
  * 5. Black balance: Every path from any node to each of its leaf nodes contains the same number of black nodes.
  */
@@ -33,9 +33,15 @@ class RedBlackTree extends bst_1.BST {
      */
     constructor(options) {
         super(options);
-        this.NIL = new RedBlackTreeNode(NaN);
+        this.Sentinel = new RedBlackTreeNode(NaN);
         this._size = 0;
-        this._root = this.NIL;
+        if (options) {
+            this.options = Object.assign({ iterationType: types_1.IterationType.ITERATIVE, comparator: (a, b) => a - b }, options);
+        }
+        else {
+            this.options = { iterationType: types_1.IterationType.ITERATIVE, comparator: (a, b) => a - b };
+        }
+        this._root = this.Sentinel;
     }
     get root() {
         return this._root;
@@ -43,6 +49,12 @@ class RedBlackTree extends bst_1.BST {
     get size() {
         return this._size;
     }
+    createNode(key, value, color = types_1.RBTNColor.BLACK) {
+        return new RedBlackTreeNode(key, value, color);
+    }
+    createTree(options) {
+        return new RedBlackTree(Object.assign(Object.assign({}, this.options), options));
+    }
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)
@@ -75,11 +87,11 @@ class RedBlackTree extends bst_1.BST {
         else {
             return;
         }
-        node.left = this.NIL;
-        node.right = this.NIL;
+        node.left = this.Sentinel;
+        node.right = this.Sentinel;
         let y = undefined;
         let x = this.root;
-        while (x !== this.NIL) {
+        while (x !== this.Sentinel) {
             y = x;
             if (x) {
                 if (node.key < x.key) {
@@ -115,9 +127,6 @@ class RedBlackTree extends bst_1.BST {
         this._fixInsert(node);
         this._size++;
     }
-    createNode(key, value, color = types_1.RBTNColor.BLACK) {
-        return new RedBlackTreeNode(key, value, color);
-    }
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)
@@ -142,9 +151,9 @@ class RedBlackTree extends bst_1.BST {
         if (identifier === null)
             return ans;
         const helper = (node) => {
-            let z = this.NIL;
+            let z = this.Sentinel;
             let x, y;
-            while (node !== this.NIL) {
+            while (node !== this.Sentinel) {
                 if (node && callback(node) === identifier) {
                     z = node;
                 }
@@ -155,17 +164,17 @@ class RedBlackTree extends bst_1.BST {
                     node = node === null || node === void 0 ? void 0 : node.left;
                 }
             }
-            if (z === this.NIL) {
+            if (z === this.Sentinel) {
                 this._size--;
                 return;
             }
             y = z;
             let yOriginalColor = y.color;
-            if (z.left === this.NIL) {
+            if (z.left === this.Sentinel) {
                 x = z.right;
                 this._rbTransplant(z, z.right);
             }
-            else if (z.right === this.NIL) {
+            else if (z.right === this.Sentinel) {
                 x = z.left;
                 this._rbTransplant(z, z.left);
             }
@@ -196,7 +205,7 @@ class RedBlackTree extends bst_1.BST {
         return ans;
     }
     isRealNode(node) {
-        return node !== this.NIL && node !== undefined;
+        return node !== this.Sentinel && node !== undefined;
     }
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
@@ -223,7 +232,7 @@ class RedBlackTree extends bst_1.BST {
      * `getNodes` method, which is called within the `getNode` method.
      * @returns a value of type `N`, `null`, or `undefined`.
      */
-    getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType) {
         var _a;
         if (identifier instanceof binary_tree_1.BinaryTreeNode)
             callback = (node => node);
@@ -244,11 +253,11 @@ class RedBlackTree extends bst_1.BST {
      */
     getSuccessor(x) {
         var _a;
-        if (x.right !== this.NIL) {
+        if (x.right !== this.Sentinel) {
             return (_a = this.getLeftMost(x.right)) !== null && _a !== void 0 ? _a : undefined;
         }
         let y = x.parent;
-        while (y !== this.NIL && y !== undefined && x === y.right) {
+        while (y !== this.Sentinel && y !== undefined && x === y.right) {
             x = y;
             y = y.parent;
         }
@@ -268,18 +277,18 @@ class RedBlackTree extends bst_1.BST {
      * @returns the predecessor of the given RedBlackTreeNode 'x'.
      */
     getPredecessor(x) {
-        if (x.left !== this.NIL) {
+        if (x.left !== this.Sentinel) {
             return this.getRightMost(x.left);
         }
         let y = x.parent;
-        while (y !== this.NIL && x === y.left) {
+        while (y !== this.Sentinel && x === y.left) {
             x = y;
             y = y.parent;
         }
         return y;
     }
     clear() {
-        this._root = this.NIL;
+        this._root = this.Sentinel;
         this._size = 0;
     }
     _setRoot(v) {
@@ -303,7 +312,7 @@ class RedBlackTree extends bst_1.BST {
         if (x.right) {
             const y = x.right;
             x.right = y.left;
-            if (y.left !== this.NIL) {
+            if (y.left !== this.Sentinel) {
                 if (y.left)
                     y.left.parent = x;
             }
@@ -337,7 +346,7 @@ class RedBlackTree extends bst_1.BST {
         if (x.left) {
             const y = x.left;
             x.left = y.right;
-            if (y.right !== this.NIL) {
+            if (y.right !== this.Sentinel) {
                 if (y.right)
                     y.right.parent = x;
             }

package/dist/data-structures/binary-tree/tree-multimap.d.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { BTNKey, TreeMultimapNodeNested, TreeMultimapOptions } from '../../types';
-import { BiTreeDeleteResult, BTNCallback, IterationType } from '../../types';
+import { BiTreeDeleteResult, BTNCallback, IterationType, TreeMultimapNested } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class TreeMultimapNode<V = any, N extends TreeMultimapNode<V, N> = TreeMultimapNodeNested<V>> extends AVLTreeNode<V, N> {
@@ -26,7 +26,8 @@ export declare class TreeMultimapNode<V = any, N extends TreeMultimapNode<V, N>
 /**
  * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
-export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultimapNode<V, TreeMultimapNodeNested<V>>> extends AVLTree<V, N> implements IBinaryTree<V, N> {
+export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultimapNode<V, TreeMultimapNodeNested<V>>, TREE extends TreeMultimap<V, N, TREE> = TreeMultimap<V, N, TreeMultimapNested<V, N>>> extends AVLTree<V, N, TREE> implements IBinaryTree<V, N, TREE> {
+    options: TreeMultimapOptions;
     /**
      * The constructor function for a TreeMultimap class in TypeScript, which extends another class and sets an option to
      * merge duplicated values.
@@ -46,6 +47,7 @@ export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = Tr
      * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
      */
     createNode(key: BTNKey, value?: V, count?: number): N;
+    createTree(options?: TreeMultimapOptions): TREE;
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -98,7 +100,7 @@ export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = Tr
      * values:
      * @returns a boolean value.
      */
-    perfectlyBalance(iterationType?: IterationType): boolean;
+    perfectlyBalance(iterationType?: IterationType | undefined): boolean;
     /**
      * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
      * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.

package/dist/data-structures/binary-tree/tree-multimap.js

@@ -30,9 +30,15 @@ class TreeMultimap extends avl_tree_1.AVLTree {
      * @param {TreeMultimapOptions} [options] - An optional object that contains additional configuration options for the
      * TreeMultimap.
      */
-    constructor(options) {
+    constructor(options = { iterationType: types_1.IterationType.ITERATIVE }) {
         super(options);
         this._count = 0;
+        if (options) {
+            this.options = Object.assign({ iterationType: types_1.IterationType.ITERATIVE, comparator: (a, b) => a - b }, options);
+        }
+        else {
+            this.options = { iterationType: types_1.IterationType.ITERATIVE, comparator: (a, b) => a - b };
+        }
     }
     get count() {
         return this._count;
@@ -49,6 +55,9 @@ class TreeMultimap extends avl_tree_1.AVLTree {
     createNode(key, value, count) {
         return new TreeMultimapNode(key, value, count);
     }
+    createTree(options) {
+        return new TreeMultimap(Object.assign(Object.assign({}, this.options), options));
+    }
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -194,7 +203,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
      * values:
      * @returns a boolean value.
      */
-    perfectlyBalance(iterationType = this.iterationType) {
+    perfectlyBalance(iterationType = this.options.iterationType) {
         const sorted = this.dfs(node => node, 'in'), n = sorted.length;
         if (sorted.length < 1)
             return false;

package/dist/data-structures/hash/hash-map.d.ts

@@ -135,8 +135,35 @@ export declare class HashMap<K = any, V = any> {
      * HashMap. It takes three arguments:
      */
     forEach(callback: (element: [K, V], index: number, hashMap: HashMap<K, V>) => void): void;
+    /**
+     * The `filter` function takes a predicate function and returns a new HashMap containing only the
+     * key-value pairs that satisfy the predicate.
+     * @param predicate - The `predicate` parameter is a function that takes two arguments: `element` and
+     * `map`.
+     * @returns a new HashMap object that contains the key-value pairs from the original HashMap that
+     * satisfy the given predicate function.
+     */
     filter(predicate: (element: [K, V], map: HashMap<K, V>) => boolean): HashMap<K, V>;
+    /**
+     * The `map` function takes a callback function and returns a new HashMap with the values transformed
+     * by the callback.
+     * @param callback - The `callback` parameter is a function that takes two arguments: `element` and
+     * `map`.
+     * @returns a new HashMap object with the values mapped according to the provided callback function.
+     */
     map<NV>(callback: (element: [K, V], map: HashMap<K, V>) => NV): HashMap<K, NV>;
+    /**
+     * The `reduce` function iterates over the elements of a HashMap and applies a callback function to
+     * each element, accumulating a single value.
+     * @param callback - The callback parameter is a function that takes three arguments: accumulator,
+     * element, and map. It is called for each element in the HashMap and is used to accumulate a single
+     * result.
+     * @param {A} initialValue - The `initialValue` parameter is the initial value of the accumulator. It
+     * is the value that will be passed as the first argument to the `callback` function when reducing
+     * the elements of the map.
+     * @returns The `reduce` function is returning the final value of the accumulator after iterating
+     * over all the elements in the HashMap and applying the callback function to each element.
+     */
     reduce<A>(callback: (accumulator: A, element: [K, V], map: HashMap<K, V>) => A, initialValue: A): A;
     /**
      * Time Complexity: O(n), where n is the number of elements in the HashMap.

package/dist/data-structures/hash/hash-map.js

@@ -277,6 +277,14 @@ class HashMap {
             node = node.next;
         }
     }
+    /**
+     * The `filter` function takes a predicate function and returns a new HashMap containing only the
+     * key-value pairs that satisfy the predicate.
+     * @param predicate - The `predicate` parameter is a function that takes two arguments: `element` and
+     * `map`.
+     * @returns a new HashMap object that contains the key-value pairs from the original HashMap that
+     * satisfy the given predicate function.
+     */
     filter(predicate) {
         const filteredMap = new HashMap();
         for (const [key, value] of this) {
@@ -286,6 +294,13 @@ class HashMap {
         }
         return filteredMap;
     }
+    /**
+     * The `map` function takes a callback function and returns a new HashMap with the values transformed
+     * by the callback.
+     * @param callback - The `callback` parameter is a function that takes two arguments: `element` and
+     * `map`.
+     * @returns a new HashMap object with the values mapped according to the provided callback function.
+     */
     map(callback) {
         const mappedMap = new HashMap();
         for (const [key, value] of this) {
@@ -294,6 +309,18 @@ class HashMap {
         }
         return mappedMap;
     }
+    /**
+     * The `reduce` function iterates over the elements of a HashMap and applies a callback function to
+     * each element, accumulating a single value.
+     * @param callback - The callback parameter is a function that takes three arguments: accumulator,
+     * element, and map. It is called for each element in the HashMap and is used to accumulate a single
+     * result.
+     * @param {A} initialValue - The `initialValue` parameter is the initial value of the accumulator. It
+     * is the value that will be passed as the first argument to the `callback` function when reducing
+     * the elements of the map.
+     * @returns The `reduce` function is returning the final value of the accumulator after iterating
+     * over all the elements in the HashMap and applying the callback function to each element.
+     */
     reduce(callback, initialValue) {
         let accumulator = initialValue;
         for (const element of this) {

package/dist/interfaces/binary-tree.d.ts

@@ -1,6 +1,6 @@
-import { BinaryTreeNode } from '../data-structures';
-import { BinaryTreeNodeNested, BiTreeDeleteResult, BTNCallback, BTNKey } from '../types';
-export interface IBinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNodeNested<V>> {
+import { BinaryTree, BinaryTreeNode } from '../data-structures';
+import { BinaryTreeNested, BinaryTreeNodeNested, BiTreeDeleteResult, BTNCallback, BTNKey } from '../types';
+export interface IBinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNodeNested<V>, TREE extends BinaryTree<V, N, TREE> = BinaryTreeNested<V, N>> {
     createNode(key: BTNKey, value?: N['value']): N;
     add(keyOrNode: BTNKey | N | null, value?: N['value']): N | null | undefined;
     delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BiTreeDeleteResult<N>[];

package/dist/types/common.d.ts

@@ -6,10 +6,6 @@ export declare enum CP {
     eq = "eq",
     gt = "gt"
 }
-export declare const enum IterateDirection {
-    DEFAULT = 0,
-    REVERSE = 1
-}
 export interface IterableWithSize<T> extends Iterable<T> {
     size: number | ((...args: any[]) => number);
 }
@@ -17,3 +13,8 @@ export interface IterableWithLength<T> extends Iterable<T> {
     length: number | ((...args: any[]) => number);
 }
 export type IterableWithSizeOrLength<T> = IterableWithSize<T> | IterableWithLength<T>;
+export type BinaryTreePrintOptions = {
+    isShowUndefined?: boolean;
+    isShowNull?: boolean;
+    isShowRedBlackNIL?: boolean;
+};

package/dist/types/data-structures/binary-tree/avl-tree.d.ts

@@ -1,4 +1,5 @@
-import { AVLTreeNode } from '../../../data-structures';
+import { AVLTree, AVLTreeNode } from '../../../data-structures';
 import { BSTOptions } from './bst';
 export type AVLTreeNodeNested<T> = AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type AVLTreeNested<T, N extends AVLTreeNode<T, N>> = AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, AVLTree<T, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type AVLTreeOptions = BSTOptions & {};

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

@@ -1,4 +1,4 @@
-import { BinaryTreeNode } from '../../../data-structures';
+import { BinaryTree, BinaryTreeNode } from '../../../data-structures';
 /**
  * Enum representing different loop types.
  *
@@ -24,6 +24,8 @@ export type BiTreeDeleteResult<N> = {
     needBalanced: N | null | undefined;
 };
 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 BinaryTreeNested<T, N extends BinaryTreeNode<T, N>> = BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BinaryTreeOptions = {
     iterationType?: IterationType;
 };
+export type NodeDisplayLayout = [string[], number, number, number];

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

@@ -22,9 +22,3 @@ var FamilyPosition;
     FamilyPosition["ISOLATED"] = "ISOLATED";
     FamilyPosition["MAL_NODE"] = "MAL_NODE";
 })(FamilyPosition = exports.FamilyPosition || (exports.FamilyPosition = {}));
-//
-// export type BTNIdentifierOrNU<N> = BTNKey | N | null | undefined;
-//
-// export type BTNIdentifierOrU<N> = BTNKey | N | undefined;
-//
-// export type BTNOrNU<N> = N | null | undefined;

package/dist/types/data-structures/binary-tree/bst.d.ts

@@ -1,7 +1,8 @@
-import { BSTNode } from '../../../data-structures';
+import { BST, BSTNode } from '../../../data-structures';
 import type { BinaryTreeOptions, BTNKey } from './binary-tree';
 export type BSTComparator = (a: BTNKey, b: BTNKey) => number;
 export type BSTNodeNested<T> = BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type BSTNested<T, N extends BSTNode<T, N>> = BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BSTOptions = BinaryTreeOptions & {
     comparator?: BSTComparator;
 };

package/dist/types/data-structures/binary-tree/rb-tree.d.ts

@@ -1,8 +1,9 @@
-import { RedBlackTreeNode } from '../../../data-structures';
+import { RedBlackTree, RedBlackTreeNode } from '../../../data-structures';
 import { BSTOptions } from "./bst";
 export declare enum RBTNColor {
     RED = 1,
     BLACK = 0
 }
 export type RedBlackTreeNodeNested<T> = RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type RedBlackTreeNested<T, N extends RedBlackTreeNode<T, N>> = RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, RedBlackTree<T, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type RBTreeOptions = BSTOptions & {};