data-structure-typed 1.46.8 → 1.46.9

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

@@ -92,15 +92,17 @@ export class BinaryTreeNode {
  * @template N - The type of the binary tree's nodes.
  */
 export class BinaryTree {
-    iterationType = IterationType.ITERATIVE;
+    options;
     /**
      * Creates a new instance of BinaryTree.
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
      */
     constructor(options) {
         if (options) {
-            const { iterationType = IterationType.ITERATIVE } = options;
-            this.iterationType = iterationType;
+            this.options = { iterationType: IterationType.ITERATIVE, ...options };
+        }
+        else {
+            this.options = { iterationType: IterationType.ITERATIVE };
         }
         this._size = 0;
     }
@@ -127,6 +129,9 @@ export class BinaryTree {
     createNode(key, value) {
         return new BinaryTreeNode(key, value);
     }
+    createTree(options) {
+        return new BinaryTree({ ...this.options, ...options });
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -358,7 +363,7 @@ export class BinaryTree {
      * values:
      * @returns the height of the binary tree.
      */
-    getHeight(beginRoot = this.root, iterationType = this.iterationType) {
+    getHeight(beginRoot = this.root, iterationType = this.options.iterationType) {
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return -1;
@@ -404,7 +409,7 @@ export class BinaryTree {
      * to calculate the minimum height of a binary tree. It can have two possible values:
      * @returns The function `getMinHeight` returns the minimum height of a binary tree.
      */
-    getMinHeight(beginRoot = this.root, iterationType = this.iterationType) {
+    getMinHeight(beginRoot = this.root, iterationType = this.options.iterationType) {
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return -1;
@@ -495,7 +500,7 @@ export class BinaryTree {
      * traverse the binary tree. It can have two possible values:
      * @returns an array of nodes of type `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) {
         if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
             callback = (node => node);
         beginRoot = this.ensureNotKey(beginRoot);
@@ -557,7 +562,7 @@ export class BinaryTree {
      * be performed in a pre-order, in-order, or post-order manner.
      * @returns a boolean value.
      */
-    has(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    has(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType) {
         if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
             callback = (node => node);
         return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
@@ -587,7 +592,7 @@ export class BinaryTree {
      * nodes are visited during the search.
      * @returns a value of type `N | null | 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 ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
             callback = (node => node);
         return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? null;
@@ -679,7 +684,7 @@ export class BinaryTree {
      * @returns The value of the node with the given identifier is being returned. If the node is not
      * found, `undefined` is returned.
      */
-    get(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    get(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType) {
         if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
             callback = (node => node);
         return this.getNode(identifier, callback, beginRoot, iterationType)?.value ?? undefined;
@@ -749,7 +754,7 @@ export class BinaryTree {
      * @returns The function `getLeftMost` returns the leftmost node (`N`) in the binary tree. If there
      * is no leftmost node, it returns `null` or `undefined` depending on the input.
      */
-    getLeftMost(beginRoot = this.root, iterationType = this.iterationType) {
+    getLeftMost(beginRoot = this.root, iterationType = this.options.iterationType) {
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return beginRoot;
@@ -790,7 +795,7 @@ export class BinaryTree {
      * @returns The function `getRightMost` returns the rightmost node (`N`) in a binary tree. If there
      * is no rightmost node, it returns `null` or `undefined`, depending on the input.
      */
-    getRightMost(beginRoot = this.root, iterationType = this.iterationType) {
+    getRightMost(beginRoot = this.root, iterationType = this.options.iterationType) {
         // TODO support get right most by passing key in
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
@@ -829,7 +834,7 @@ export class BinaryTree {
      * possible values:
      * @returns a boolean value.
      */
-    isSubtreeBST(beginRoot, iterationType = this.iterationType) {
+    isSubtreeBST(beginRoot, iterationType = this.options.iterationType) {
         // TODO there is a bug
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
@@ -876,7 +881,7 @@ export class BinaryTree {
      * expected to be
      * @returns a boolean value.
      */
-    isBST(iterationType = this.iterationType) {
+    isBST(iterationType = this.options.iterationType) {
         if (this.root === null)
             return true;
         return this.isSubtreeBST(this.root, iterationType);
@@ -901,13 +906,13 @@ export class BinaryTree {
      * @param iterationType - The `iterationType` parameter determines the type of traversal to be
      * performed on the subtree. It can have two possible values:
      * @param [includeNull=false] - The `includeNull` parameter is a boolean value that determines
-     * whether or not to include null values in the traversal. If `includeNull` is set to `true`, the
+     * whether to include null values in the traversal. If `includeNull` is set to `true`, the
      * traversal will include null values, otherwise it will skip them.
      * @returns The function `subTreeTraverse` returns an array of values that are the result of invoking
      * the `callback` function on each node in the subtree. The type of the array elements is determined
      * by the return type of the `callback` function.
      */
-    subTreeTraverse(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
+    subTreeTraverse(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType, includeNull = false) {
         beginRoot = this.ensureNotKey(beginRoot);
         const ans = [];
         if (!beginRoot)
@@ -1134,12 +1139,12 @@ export class BinaryTree {
      * @param iterationType - The `iterationType` parameter determines the type of iteration to be
      * performed during the breadth-first search (BFS). It can have two possible values:
      * @param [includeNull=false] - The `includeNull` parameter is a boolean flag that determines whether
-     * or not to include null values in the breadth-first search traversal. If `includeNull` is set to
+     * to include null values in the breadth-first search traversal. If `includeNull` is set to
      * `true`, null values will be included in the traversal, otherwise they will be skipped.
      * @returns an array of values that are the result of invoking the callback function on each node in
      * the breadth-first traversal of a binary tree.
      */
-    bfs(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
+    bfs(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType, includeNull = false) {
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return [];
@@ -1211,12 +1216,12 @@ export class BinaryTree {
      * @param iterationType - The `iterationType` parameter determines the type of iteration to be
      * performed on the tree. It can have two possible values:
      * @param [includeNull=false] - The `includeNull` parameter is a boolean value that determines
-     * whether or not to include null values in the resulting levels. If `includeNull` is set to `true`,
+     * whether to include null values in the resulting levels. If `includeNull` is set to `true`,
      * null values will be included in the levels. If `includeNull` is set to `false`, null values will
      * be excluded
      * @returns The function `listLevels` returns a two-dimensional array of type `ReturnType<C>[][]`.
      */
-    listLevels(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
+    listLevels(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType, includeNull = false) {
         beginRoot = this.ensureNotKey(beginRoot);
         const levelsNodes = [];
         if (!beginRoot)
@@ -1415,6 +1420,42 @@ export class BinaryTree {
         }
         return ans;
     }
+    forEach(callback) {
+        for (const entry of this) {
+            callback(entry, this);
+        }
+    }
+    filter(predicate) {
+        const newTree = this.createTree();
+        for (const [key, value] of this) {
+            if (predicate([key, value], this)) {
+                newTree.add(key, value);
+            }
+        }
+        return newTree;
+    }
+    // TODO Type error, need to return a TREE<NV> that is a value type only for callback function.
+    // map<NV>(callback: (entry: [BTNKey, V | undefined], tree: typeof this) => NV) {
+    //   const newTree = this.createTree();
+    //   for (const [key, value] of this) {
+    //     newTree.add(key, callback([key, value], this));
+    //   }
+    //   return newTree;
+    // }
+    map(callback) {
+        const newTree = this.createTree();
+        for (const [key, value] of this) {
+            newTree.add(key, callback([key, value], this));
+        }
+        return newTree;
+    }
+    reduce(callback, initialValue) {
+        let accumulator = initialValue;
+        for (const [key, value] of this) {
+            accumulator = callback(accumulator, [key, value], this);
+        }
+        return accumulator;
+    }
     /**
      * The above function is an iterator for a binary tree that can be used to traverse the tree in
      * either an iterative or recursive manner.
@@ -1425,78 +1466,104 @@ export class BinaryTree {
      * binary tree nodes in a specific order.
      */
     *[Symbol.iterator](node = this.root) {
-        if (!node) {
+        if (!node)
             return;
-        }
-        if (this.iterationType === IterationType.ITERATIVE) {
+        if (this.options.iterationType === IterationType.ITERATIVE) {
             const stack = [];
             let current = node;
             while (current || stack.length > 0) {
-                while (current) {
+                while (current && !isNaN(current.key)) {
                     stack.push(current);
                     current = current.left;
                 }
                 current = stack.pop();
-                if (current)
-                    yield current.key;
-                if (current)
+                if (current && !isNaN(current.key)) {
+                    yield [current.key, current.value];
                     current = current.right;
+                }
             }
         }
         else {
-            if (node.left) {
+            if (node.left && !isNaN(node.key)) {
                 yield* this[Symbol.iterator](node.left);
             }
-            yield node.key;
-            if (node.right) {
+            yield [node.key, node.value];
+            if (node.right && !isNaN(node.key)) {
                 yield* this[Symbol.iterator](node.right);
             }
         }
     }
     /**
      * The `print` function is used to display a binary tree structure in a visually appealing way.
-     * @param {N | null | undefined} beginRoot - The `root` parameter is of type `BTNKey | N | null |
+     * @param {BTNKey | N | null | undefined} [beginRoot=this.root] - The `root` parameter is of type `BTNKey | N | null |
      * undefined`. It represents the root node of a binary tree. The root node can have one of the
      * following types:
+     * @param {BinaryTreePrintOptions} [options={ isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false}] - Options object that controls printing behavior. You can specify whether to display undefined, null, or sentinel nodes.
      */
-    print(beginRoot = this.root) {
+    print(beginRoot = this.root, options) {
+        const opts = { isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false, ...options };
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return;
+        if (opts.isShowUndefined)
+            console.log(`U for undefined
+      `);
+        if (opts.isShowNull)
+            console.log(`N for null
+      `);
+        if (opts.isShowRedBlackNIL)
+            console.log(`S for Sentinel Node
+      `);
         const display = (root) => {
-            const [lines, , ,] = this._displayAux(root);
+            const [lines, , ,] = this._displayAux(root, opts);
             for (const line of lines) {
                 console.log(line);
             }
         };
         display(beginRoot);
     }
-    _displayAux(node) {
-        if (!node) {
-            return [['─'], 1, 0, 0];
+    _displayAux(node, options) {
+        const { isShowNull, isShowUndefined, isShowRedBlackNIL } = options;
+        const emptyDisplayLayout = [['─'], 1, 0, 0];
+        // Check if node is null or undefined or key is NaN
+        if (node === null && !isShowNull) {
+            return emptyDisplayLayout;
+        }
+        else if (node === undefined && !isShowUndefined) {
+            return emptyDisplayLayout;
         }
-        const line = node.key.toString();
-        const width = line.length;
-        if (!node.left && !node.right) {
-            return [[line], width, 1, Math.floor(width / 2)];
+        else if (node !== null && node !== undefined && isNaN(node.key) && !isShowRedBlackNIL) {
+            return emptyDisplayLayout;
         }
-        const [leftLines, leftWidth, leftHeight, leftMiddle] = node.left ? this._displayAux(node.left) : [[''], 0, 0, 0];
-        const [rightLines, rightWidth, rightHeight, rightMiddle] = node.right ? this._displayAux(node.right) : [[''], 0, 0, 0];
-        const firstLine = ' '.repeat(Math.max(0, leftMiddle + 1))
-            + '_'.repeat(Math.max(0, leftWidth - leftMiddle - 1))
-            + line
-            + '_'.repeat(Math.max(0, rightMiddle))
-            + ' '.repeat(Math.max(0, rightWidth - rightMiddle));
-        const secondLine = (leftHeight > 0 ? ' '.repeat(leftMiddle) + '/' + ' '.repeat(leftWidth - leftMiddle - 1) : ' '.repeat(leftWidth))
-            + ' '.repeat(width)
-            + (rightHeight > 0 ? ' '.repeat(rightMiddle) + '\\' + ' '.repeat(rightWidth - rightMiddle - 1) : ' '.repeat(rightWidth));
-        const mergedLines = [firstLine, secondLine];
-        for (let i = 0; i < Math.max(leftHeight, rightHeight); i++) {
-            const leftLine = i < leftHeight ? leftLines[i] : ' '.repeat(leftWidth);
-            const rightLine = i < rightHeight ? rightLines[i] : ' '.repeat(rightWidth);
-            mergedLines.push(leftLine + ' '.repeat(width) + rightLine);
+        else if (node !== null && node !== undefined) {
+            // Display logic of normal nodes
+            const key = node.key, line = isNaN(key) ? 'S' : key.toString(), width = line.length;
+            return _buildNodeDisplay(line, width, this._displayAux(node.left, options), this._displayAux(node.right, options));
+        }
+        else {
+            // For cases where none of the conditions are met, null, undefined, and NaN nodes are not displayed
+            const line = node === undefined ? 'U' : 'N', width = line.length;
+            return _buildNodeDisplay(line, width, [[''], 1, 0, 0], [[''], 1, 0, 0]);
+        }
+        function _buildNodeDisplay(line, width, left, right) {
+            const [leftLines, leftWidth, leftHeight, leftMiddle] = left;
+            const [rightLines, rightWidth, rightHeight, rightMiddle] = right;
+            const firstLine = ' '.repeat(Math.max(0, leftMiddle + 1))
+                + '_'.repeat(Math.max(0, leftWidth - leftMiddle - 1))
+                + line
+                + '_'.repeat(Math.max(0, rightMiddle))
+                + ' '.repeat(Math.max(0, rightWidth - rightMiddle));
+            const secondLine = (leftHeight > 0 ? ' '.repeat(leftMiddle) + '/' + ' '.repeat(leftWidth - leftMiddle - 1) : ' '.repeat(leftWidth))
+                + ' '.repeat(width)
+                + (rightHeight > 0 ? ' '.repeat(rightMiddle) + '\\' + ' '.repeat(rightWidth - rightMiddle - 1) : ' '.repeat(rightWidth));
+            const mergedLines = [firstLine, secondLine];
+            for (let i = 0; i < Math.max(leftHeight, rightHeight); i++) {
+                const leftLine = i < leftHeight ? leftLines[i] : ' '.repeat(leftWidth);
+                const rightLine = i < rightHeight ? rightLines[i] : ' '.repeat(rightWidth);
+                mergedLines.push(leftLine + ' '.repeat(width) + rightLine);
+            }
+            return [mergedLines, leftWidth + width + rightWidth, Math.max(leftHeight, rightHeight) + 2, leftWidth + Math.floor(width / 2)];
         }
-        return [mergedLines, leftWidth + width + rightWidth, Math.max(leftHeight, rightHeight) + 2, leftWidth + Math.floor(width / 2)];
     }
     _defaultOneParamCallback = (node) => node.key;
     /**

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)