data-structure-typed 1.46.7 → 1.46.9

package/dist/mjs/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/mjs/data-structures/binary-tree/bst.js

@@ -45,6 +45,7 @@ export class BSTNode extends BinaryTreeNode {
     }
 }
 export class BST extends BinaryTree {
+    options;
     /**
      * The constructor function initializes a binary search tree with an optional comparator function.
      * @param {BSTOptions} [options] - An optional object that contains additional configuration options
@@ -52,13 +53,13 @@ export class BST extends BinaryTree {
      */
     constructor(options) {
         super(options);
-        this._root = undefined;
-        if (options !== undefined) {
-            const { comparator } = options;
-            if (comparator !== undefined) {
-                this._comparator = comparator;
-            }
+        if (options) {
+            this.options = { iterationType: IterationType.ITERATIVE, comparator: (a, b) => a - b, ...options };
+        }
+        else {
+            this.options = { iterationType: IterationType.ITERATIVE, comparator: (a, b) => a - b };
         }
+        this._root = undefined;
     }
     _root;
     /**
@@ -78,6 +79,9 @@ export class BST extends BinaryTree {
     createNode(key, value) {
         return new BSTNode(key, value);
     }
+    createTree(options) {
+        return new BST({ ...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.
@@ -195,7 +199,7 @@ export class BST extends 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;
@@ -283,7 +287,7 @@ export class BST extends 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) {
         if (this._compare(0, 1) === CP.lt)
             return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
         else if (this._compare(0, 1) === CP.gt)
@@ -379,7 +383,7 @@ export class BST extends 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 [];
@@ -460,7 +464,7 @@ export class BST extends 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 = CP.lt, targetNode = this.root, iterationType = this.iterationType) {
+    lesserOrGreaterTraverse(callback = this._defaultOneParamCallback, lesserOrGreater = CP.lt, targetNode = this.root, iterationType = this.options.iterationType) {
         targetNode = this.ensureNotKey(targetNode);
         const ans = [];
         if (!targetNode)
@@ -524,7 +528,7 @@ export class BST extends 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)
@@ -574,7 +578,7 @@ export class BST extends 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) {
         if (!this.root)
             return true;
         let balanced = true;
@@ -619,7 +623,6 @@ export class BST extends BinaryTree {
         }
         return balanced;
     }
-    _comparator = (a, b) => a - b;
     _setRoot(v) {
         if (v) {
             v.parent = undefined;
@@ -635,7 +638,7 @@ export class BST extends 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 CP.gt;
         else if (compared < 0)

package/dist/mjs/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/mjs/data-structures/binary-tree/rb-tree.js

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { RBTNColor } from '../../types';
+import { IterationType, RBTNColor } from '../../types';
 import { BST, BSTNode } from './bst';
 import { BinaryTreeNode } from './binary-tree';
 export class RedBlackTreeNode extends BSTNode {
@@ -18,12 +18,13 @@ export class RedBlackTreeNode extends BSTNode {
 /**
  * 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 class RedBlackTree extends BST {
-    NIL = new RedBlackTreeNode(NaN);
+    Sentinel = new RedBlackTreeNode(NaN);
+    options;
     /**
      * 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,7 +32,13 @@ export class RedBlackTree extends BST {
      */
     constructor(options) {
         super(options);
-        this._root = this.NIL;
+        if (options) {
+            this.options = { iterationType: IterationType.ITERATIVE, comparator: (a, b) => a - b, ...options };
+        }
+        else {
+            this.options = { iterationType: IterationType.ITERATIVE, comparator: (a, b) => a - b };
+        }
+        this._root = this.Sentinel;
     }
     _root;
     get root() {
@@ -41,6 +48,12 @@ export class RedBlackTree extends BST {
     get size() {
         return this._size;
     }
+    createNode(key, value, color = RBTNColor.BLACK) {
+        return new RedBlackTreeNode(key, value, color);
+    }
+    createTree(options) {
+        return new RedBlackTree({ ...this.options, ...options });
+    }
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)
@@ -73,11 +86,11 @@ export class RedBlackTree extends 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) {
@@ -113,9 +126,6 @@ export class RedBlackTree extends BST {
         this._fixInsert(node);
         this._size++;
     }
-    createNode(key, value, color = 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)
@@ -140,9 +150,9 @@ export class RedBlackTree extends 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;
                 }
@@ -153,17 +163,17 @@ export class RedBlackTree extends BST {
                     node = 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);
             }
@@ -194,7 +204,7 @@ export class RedBlackTree extends 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)
@@ -221,7 +231,7 @@ export class RedBlackTree extends 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) {
         if (identifier instanceof BinaryTreeNode)
             callback = (node => node);
         beginRoot = this.ensureNotKey(beginRoot);
@@ -240,11 +250,11 @@ export class RedBlackTree extends BST {
      * @returns the successor of the given RedBlackTreeNode.
      */
     getSuccessor(x) {
-        if (x.right !== this.NIL) {
+        if (x.right !== this.Sentinel) {
             return this.getLeftMost(x.right) ?? 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;
         }
@@ -264,18 +274,18 @@ export class RedBlackTree extends 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) {
@@ -299,7 +309,7 @@ export class RedBlackTree extends 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;
             }
@@ -333,7 +343,7 @@ export class RedBlackTree extends 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/mjs/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/mjs/data-structures/binary-tree/tree-multimap.js

@@ -21,14 +21,21 @@ export class TreeMultimapNode extends AVLTreeNode {
  * 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 class TreeMultimap extends AVLTree {
+    options;
     /**
      * The constructor function for a TreeMultimap class in TypeScript, which extends another class and sets an option to
      * merge duplicated values.
      * @param {TreeMultimapOptions} [options] - An optional object that contains additional configuration options for the
      * TreeMultimap.
      */
-    constructor(options) {
+    constructor(options = { iterationType: IterationType.ITERATIVE }) {
         super(options);
+        if (options) {
+            this.options = { iterationType: IterationType.ITERATIVE, comparator: (a, b) => a - b, ...options };
+        }
+        else {
+            this.options = { iterationType: IterationType.ITERATIVE, comparator: (a, b) => a - b };
+        }
     }
     _count = 0;
     get count() {
@@ -46,6 +53,9 @@ export class TreeMultimap extends AVLTree {
     createNode(key, value, count) {
         return new TreeMultimapNode(key, value, count);
     }
+    createTree(options) {
+        return new TreeMultimap({ ...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.
@@ -191,7 +201,7 @@ export class TreeMultimap extends 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/mjs/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/mjs/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/mjs/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/mjs/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/mjs/types/data-structures/binary-tree/binary-tree.js

@@ -19,9 +19,3 @@ export var FamilyPosition;
     FamilyPosition["ISOLATED"] = "ISOLATED";
     FamilyPosition["MAL_NODE"] = "MAL_NODE";
 })(FamilyPosition || (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/mjs/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/mjs/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 & {};

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

@@ -1,4 +1,5 @@
-import { TreeMultimapNode } from '../../../data-structures';
+import { TreeMultimap, TreeMultimapNode } from '../../../data-structures';
 import { AVLTreeOptions } from './avl-tree';
 export type TreeMultimapNodeNested<T> = TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type TreeMultimapNested<T, N extends TreeMultimapNode<T, N>> = TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, TreeMultimap<T, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type TreeMultimapOptions = Omit<AVLTreeOptions, 'isMergeDuplicatedNodeByKey'> & {};