priority-queue-typed 1.46.7 → 1.46.9

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

@@ -6,14 +6,15 @@
  * @license MIT License
  */
 import { BST, BSTNode } from './bst';
-import type { AVLTreeNodeNested, AVLTreeOptions, BiTreeDeleteResult, BTNKey } from '../../types';
+import type { AVLTreeNested, AVLTreeNodeNested, AVLTreeOptions, BiTreeDeleteResult, BTNKey } from '../../types';
 import { BTNCallback } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 export declare class AVLTreeNode<V = any, N extends AVLTreeNode<V, N> = AVLTreeNodeNested<V>> extends BSTNode<V, N> {
     height: number;
     constructor(key: BTNKey, value?: V);
 }
-export declare class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTreeNodeNested<V>>> extends BST<V, N> implements IBinaryTree<V, N> {
+export declare class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTreeNodeNested<V>>, TREE extends AVLTree<V, N, TREE> = AVLTree<V, N, AVLTreeNested<V, N>>> extends BST<V, N, TREE> implements IBinaryTree<V, N, TREE> {
+    options: AVLTreeOptions;
     /**
      * This is a constructor function for an AVL tree data structure in TypeScript.
      * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be passed to the
@@ -31,6 +32,7 @@ export declare class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<
      * @returns a new AVLTreeNode object with the specified key and value.
      */
     createNode(key: BTNKey, value?: V): N;
+    createTree(options?: AVLTreeOptions): TREE;
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.

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

@@ -9,6 +9,7 @@ exports.AVLTree = exports.AVLTreeNode = void 0;
  * @license MIT License
  */
 const bst_1 = require("./bst");
+const types_1 = require("../../types");
 class AVLTreeNode extends bst_1.BSTNode {
     constructor(key, value) {
         super(key, value);
@@ -25,6 +26,12 @@ class AVLTree extends bst_1.BST {
      */
     constructor(options) {
         super(options);
+        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 };
+        }
     }
     /**
      * The function creates a new AVL tree node with the specified key and value.
@@ -38,6 +45,9 @@ class AVLTree extends bst_1.BST {
     createNode(key, value) {
         return new AVLTreeNode(key, value);
     }
+    createTree(options) {
+        return new AVLTree(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 (BST) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.

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

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { BinaryTreeNodeNested, BinaryTreeOptions, BTNCallback, BTNKey } from '../../types';
-import { BiTreeDeleteResult, DFSOrderPattern, FamilyPosition, IterationType } from '../../types';
+import { BinaryTreeNested, BinaryTreePrintOptions, BiTreeDeleteResult, DFSOrderPattern, FamilyPosition, IterationType, NodeDisplayLayout } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 /**
  * Represents a node in a binary tree.
@@ -62,8 +62,8 @@ export declare class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = Bi
  * Represents a binary tree data structure.
  * @template N - The type of the binary tree's nodes.
  */
-export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>> implements IBinaryTree<V, N> {
-    iterationType: IterationType;
+export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>, TREE extends BinaryTree<V, N, TREE> = BinaryTree<V, N, BinaryTreeNested<V, N>>> implements IBinaryTree<V, N, TREE> {
+    options: BinaryTreeOptions;
     /**
      * Creates a new instance of BinaryTree.
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
@@ -86,6 +86,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns {N} - The newly created BinaryTreeNode.
      */
     createNode(key: BTNKey, value?: V): N;
+    createTree(options?: BinaryTreeOptions): TREE;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -181,7 +182,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * values:
      * @returns the height of the binary tree.
      */
-    getHeight(beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): number;
+    getHeight(beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType | undefined): number;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -200,7 +201,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * 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?: BTNKey | N | null | undefined, iterationType?: IterationType): number;
+    getMinHeight(beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType | undefined): number;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -306,7 +307,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @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?: BTNKey | N | null | undefined, iterationType?: IterationType): N | null | undefined;
+    getLeftMost(beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType | undefined): N | null | undefined;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -326,7 +327,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @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?: BTNKey | N | null | undefined, iterationType?: IterationType): N | null | undefined;
+    getRightMost(beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType | undefined): N | null | undefined;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -343,7 +344,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * possible values:
      * @returns a boolean value.
      */
-    isSubtreeBST(beginRoot: BTNKey | N | null | undefined, iterationType?: IterationType): boolean;
+    isSubtreeBST(beginRoot: BTNKey | N | null | undefined, iterationType?: IterationType | undefined): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -359,7 +360,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * expected to be
      * @returns a boolean value.
      */
-    isBST(iterationType?: IterationType): boolean;
+    isBST(iterationType?: IterationType | undefined): boolean;
     subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
     subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
     subTreeTraverse<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
@@ -429,6 +430,10 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * by the return type of the `callback` function.
      */
     morris<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNKey | N | null | undefined): ReturnType<C>[];
+    forEach(callback: (entry: [BTNKey, V | undefined], tree: typeof this) => void): void;
+    filter(predicate: (entry: [BTNKey, V | undefined], tree: typeof this) => boolean): TREE;
+    map(callback: (entry: [BTNKey, V | undefined], tree: typeof this) => V): TREE;
+    reduce<T>(callback: (accumulator: T, entry: [BTNKey, V | undefined], tree: typeof this) => T, initialValue: T): T;
     /**
      * 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.
@@ -438,15 +443,16 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns The `*[Symbol.iterator]` method returns a generator object that yields the keys of the
      * binary tree nodes in a specific order.
      */
-    [Symbol.iterator](node?: N | null | undefined): Generator<BTNKey, void, undefined>;
+    [Symbol.iterator](node?: N | null | undefined): Generator<[BTNKey, V | undefined], void, undefined>;
     /**
      * 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?: BTNKey | N | null | undefined): void;
-    protected _displayAux(node: N | null | undefined): [string[], number, number, number];
+    print(beginRoot?: BTNKey | N | null | undefined, options?: BinaryTreePrintOptions): void;
+    protected _displayAux(node: N | null | undefined, options: BinaryTreePrintOptions): NodeDisplayLayout;
     protected _defaultOneParamCallback: (node: N) => number;
     /**
      * Swap the data of two nodes in the binary tree.

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

@@ -87,11 +87,12 @@ class BinaryTree {
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
      */
     constructor(options) {
-        this.iterationType = types_1.IterationType.ITERATIVE;
         this._defaultOneParamCallback = (node) => node.key;
         if (options) {
-            const { iterationType = types_1.IterationType.ITERATIVE } = options;
-            this.iterationType = iterationType;
+            this.options = Object.assign({ iterationType: types_1.IterationType.ITERATIVE }, options);
+        }
+        else {
+            this.options = { iterationType: types_1.IterationType.ITERATIVE };
         }
         this._size = 0;
     }
@@ -116,6 +117,9 @@ class BinaryTree {
     createNode(key, value) {
         return new BinaryTreeNode(key, value);
     }
+    createTree(options) {
+        return new BinaryTree(Object.assign(Object.assign({}, this.options), options));
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -347,7 +351,7 @@ 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;
@@ -393,7 +397,7 @@ 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) {
         var _a, _b, _c;
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
@@ -485,7 +489,7 @@ 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);
@@ -547,7 +551,7 @@ 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;
@@ -577,7 +581,7 @@ 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) {
         var _a;
         if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
             callback = (node => node);
@@ -670,7 +674,7 @@ 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) {
         var _a, _b;
         if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
             callback = (node => node);
@@ -741,7 +745,7 @@ 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;
@@ -782,7 +786,7 @@ 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)
@@ -821,7 +825,7 @@ 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)
@@ -868,7 +872,7 @@ 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);
@@ -893,13 +897,13 @@ 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)
@@ -1126,12 +1130,12 @@ 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 [];
@@ -1203,12 +1207,12 @@ 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)
@@ -1407,6 +1411,42 @@ 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.
@@ -1417,78 +1457,104 @@ class BinaryTree {
      * binary tree nodes in a specific order.
      */
     *[Symbol.iterator](node = this.root) {
-        if (!node) {
+        if (!node)
             return;
-        }
-        if (this.iterationType === types_1.IterationType.ITERATIVE) {
+        if (this.options.iterationType === types_1.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 = Object.assign({ 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)];
     }
     /**
      * Swap the data of two nodes in the binary tree.

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