avl-tree-typed 1.46.8 → 1.47.2

package/dist/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'> & {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "avl-tree-typed",
-  "version": "1.46.8",
+  "version": "1.47.2",
   "description": "AVLTree(Adelson-Velsky and Landis Tree). Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -163,6 +163,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.46.7"
+    "data-structure-typed": "^1.47.2"
   }
 }

package/src/data-structures/binary-tree/avl-tree.ts

@@ -6,8 +6,8 @@
  * @license MIT License
  */
 import { BST, BSTNode } from './bst';
-import type { AVLTreeNodeNested, AVLTreeOptions, BiTreeDeleteResult, BTNKey } from '../../types';
-import { BTNCallback } from '../../types';
+import type { AVLTreeNested, AVLTreeNodeNested, AVLTreeOptions, BiTreeDeleteResult, BTNKey } from '../../types';
+import { BTNCallback, IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 
 export class AVLTreeNode<V = any, N extends AVLTreeNode<V, N> = AVLTreeNodeNested<V>> extends BSTNode<V, N> {
@@ -19,9 +19,12 @@ export class AVLTreeNode<V = any, N extends AVLTreeNode<V, N> = AVLTreeNodeNeste
   }
 }
 
-export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTreeNodeNested<V>>>
-  extends BST<V, N>
-  implements IBinaryTree<V, N> {
+export 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> {
+
+  override 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
@@ -30,6 +33,11 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
    */
   constructor(options?: AVLTreeOptions) {
     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 };
+    }
   }
 
   /**
@@ -45,6 +53,10 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
     return new AVLTreeNode<V, N>(key, value) as N;
   }
 
+  override createTree(options?: AVLTreeOptions): TREE {
+    return new AVLTree<V, N, TREE>({ ...this.options, ...options }) as 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/src/data-structures/binary-tree/binary-tree.ts

@@ -7,7 +7,15 @@
  */
 
 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';
 import { trampoline } from '../../utils';
 import { Queue } from '../queue';
@@ -107,9 +115,10 @@ export class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = BinaryTree
  * Represents a binary tree data structure.
  * @template N - The type of the binary tree's nodes.
  */
-export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>>
-  implements IBinaryTree<V, N> {
-  iterationType: IterationType = IterationType.ITERATIVE;
+export 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.
@@ -117,9 +126,11 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    */
   constructor(options?: BinaryTreeOptions) {
     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;
   }
 
@@ -151,6 +162,10 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return new BinaryTreeNode<V, N>(key, value) as N;
   }
 
+  createTree(options?: BinaryTreeOptions): TREE {
+    return new BinaryTree<V, N, TREE>({ ...this.options, ...options }) as TREE;
+  }
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -397,7 +412,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * values:
    * @returns the height of the binary tree.
    */
-  getHeight(beginRoot: BTNKey | N | null | undefined = this.root, iterationType = this.iterationType): number {
+  getHeight(beginRoot: BTNKey | N | null | undefined = this.root, iterationType = this.options.iterationType): number {
     beginRoot = this.ensureNotKey(beginRoot);
     if (!beginRoot) return -1;
 
@@ -446,7 +461,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * 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 = this.root, iterationType = this.iterationType): number {
+  getMinHeight(beginRoot: BTNKey | N | null | undefined = this.root, iterationType = this.options.iterationType): number {
     beginRoot = this.ensureNotKey(beginRoot);
     if (!beginRoot) return -1;
 
@@ -568,7 +583,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     callback: C = this._defaultOneParamCallback as C,
     onlyOne = false,
     beginRoot: BTNKey | N | null | undefined = this.root,
-    iterationType = this.iterationType
+    iterationType = this.options.iterationType
   ): N[] {
     if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
       callback = (node => node) as C;
@@ -657,7 +672,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     identifier: ReturnType<C> | null | undefined,
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: BTNKey | N | null | undefined = this.root,
-    iterationType = this.iterationType
+    iterationType = this.options.iterationType
   ): boolean {
     if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
       callback = (node => node) as C;
@@ -716,7 +731,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     identifier: ReturnType<C> | null | undefined,
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: BTNKey | N | null | undefined = this.root,
-    iterationType = this.iterationType
+    iterationType = this.options.iterationType
   ): N | null | undefined {
     if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
       callback = (node => node) as C;
@@ -835,7 +850,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     identifier: ReturnType<C> | null | undefined,
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: BTNKey | N | null | undefined = this.root,
-    iterationType = this.iterationType
+    iterationType = this.options.iterationType
   ): V | undefined {
     if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
       callback = (node => node) as C;
@@ -916,7 +931,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    */
   getLeftMost(
     beginRoot: BTNKey | N | null | undefined = this.root,
-    iterationType = this.iterationType
+    iterationType = this.options.iterationType
   ): N | null | undefined {
     beginRoot = this.ensureNotKey(beginRoot);
 
@@ -962,7 +977,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    */
   getRightMost(
     beginRoot: BTNKey | N | null | undefined = this.root,
-    iterationType = this.iterationType
+    iterationType = this.options.iterationType
   ): N | null | undefined {
     // TODO support get right most by passing key in
     beginRoot = this.ensureNotKey(beginRoot);
@@ -1003,7 +1018,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * possible values:
    * @returns a boolean value.
    */
-  isSubtreeBST(beginRoot: BTNKey | N | null | undefined, iterationType = this.iterationType): boolean {
+  isSubtreeBST(beginRoot: BTNKey | N | null | undefined, iterationType = this.options.iterationType): boolean {
     // TODO there is a bug
     beginRoot = this.ensureNotKey(beginRoot);
     if (!beginRoot) return true;
@@ -1050,7 +1065,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * expected to be
    * @returns a boolean value.
    */
-  isBST(iterationType = this.iterationType): boolean {
+  isBST(iterationType = this.options.iterationType): boolean {
     if (this.root === null) return true;
     return this.isSubtreeBST(this.root, iterationType);
   }
@@ -1097,7 +1112,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @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
@@ -1106,7 +1121,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
   subTreeTraverse<C extends BTNCallback<N | null | undefined>>(
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: BTNKey | N | null | undefined = this.root,
-    iterationType = this.iterationType,
+    iterationType = this.options.iterationType,
     includeNull = false
   ): ReturnType<C>[] {
     beginRoot = this.ensureNotKey(beginRoot);
@@ -1376,7 +1391,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @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.
@@ -1384,7 +1399,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
   bfs<C extends BTNCallback<N | null | undefined>>(
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: BTNKey | N | null | undefined = this.root,
-    iterationType = this.iterationType,
+    iterationType = this.options.iterationType,
     includeNull = false
   ): ReturnType<C>[] {
     beginRoot = this.ensureNotKey(beginRoot);
@@ -1477,7 +1492,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @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>[][]`.
@@ -1485,7 +1500,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
   listLevels<C extends BTNCallback<N | null | undefined>>(
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: BTNKey | N | null | undefined = this.root,
-    iterationType = this.iterationType,
+    iterationType = this.options.iterationType,
     includeNull = false
   ): ReturnType<C>[][] {
     beginRoot = this.ensureNotKey(beginRoot);
@@ -1685,6 +1700,80 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return ans;
   }
 
+  /**
+   * The `forEach` function iterates over each entry in a tree and calls a callback function with the
+   * entry and the tree as arguments.
+   * @param callback - The callback parameter is a function that will be called for each entry in the
+   * tree. It takes two parameters: entry and tree.
+   */
+  forEach(callback: (entry: [BTNKey, V | undefined], tree: this) => void): void {
+    for (const entry of this) {
+      callback(entry, this);
+    }
+  }
+
+  /**
+   * The `filter` function creates a new tree by iterating over the entries of the current tree and
+   * adding the entries that satisfy the given predicate.
+   * @param predicate - The `predicate` parameter is a function that takes two arguments: `entry` and
+   * `tree`.
+   * @returns The `filter` method is returning a new tree object that contains only the entries that
+   * satisfy the given predicate function.
+   */
+  filter(predicate: (entry: [BTNKey, V | undefined], tree: this) => boolean) {
+    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: this) => NV) {
+  //   const newTree = this.createTree();
+  //   for (const [key, value] of this) {
+  //     newTree.add(key, callback([key, value], this));
+  //   }
+  //   return newTree;
+  // }
+
+  /**
+   * The `map` function creates a new tree by applying a callback function to each entry in the current
+   * tree.
+   * @param callback - The callback parameter is a function that takes two arguments: entry and tree.
+   * @returns The `map` method is returning a new tree object.
+   */
+  map(callback: (entry: [BTNKey, V | undefined], tree: this) => V) {
+    const newTree = this.createTree();
+    for (const [key, value] of this) {
+      newTree.add(key, callback([key, value], this));
+    }
+    return newTree;
+  }
+
+  /**
+   * The `reduce` function iterates over the entries of a tree and applies a callback function to each
+   * entry, accumulating a single value.
+   * @param callback - The callback parameter is a function that takes three arguments: accumulator,
+   * entry, and tree. It is called for each entry in the tree and is used to accumulate a single value
+   * based on the logic defined in the callback function.
+   * @param {T} initialValue - The initialValue parameter is the initial value of the accumulator. It
+   * is the value that will be passed as the first argument to the callback function when reducing the
+   * elements of the tree.
+   * @returns The `reduce` method is returning the final value of the accumulator after iterating over
+   * all the entries in the tree and applying the callback function to each entry.
+   */
+  reduce<T>(callback: (accumulator: T, entry: [BTNKey, V | undefined], tree: this) => T, initialValue: T): T {
+    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.
@@ -1694,32 +1783,32 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @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 = this.root): Generator<BTNKey, void, undefined> {
-    if (!node) {
-      return;
-    }
+  * [Symbol.iterator](node = this.root): Generator<[BTNKey, V | undefined], void, undefined> {
+    if (!node) return;
 
-    if (this.iterationType === IterationType.ITERATIVE) {
+    if (this.options.iterationType === IterationType.ITERATIVE) {
       const stack: (N | null | undefined)[] = [];
       let current: N | null | undefined = 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) current = current.right;
+        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);
       }
     }
@@ -1727,16 +1816,25 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
 
   /**
    * 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 = this.root): void {
+  print(beginRoot: BTNKey | N | null | undefined = this.root, options?: BinaryTreePrintOptions): void {
+    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: N | null | undefined): void => {
-      const [lines, , ,] = this._displayAux(root);
+      const [lines, , ,] = this._displayAux(root, opts);
       for (const line of lines) {
         console.log(line);
       }
@@ -1745,39 +1843,54 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     display(beginRoot);
   }
 
-  protected _displayAux(node: N | null | undefined): [string[], number, number, number] {
-    if (!node) {
-      return [['─'], 1, 0, 0];
-    }
+  protected _displayAux(node: N | null | undefined, options: BinaryTreePrintOptions): NodeDisplayLayout {
+    const { isShowNull, isShowUndefined, isShowRedBlackNIL } = options;
+    const emptyDisplayLayout = <NodeDisplayLayout>[['─'], 1, 0, 0];
 
-    const line = node.key.toString();
-    const width = line.length;
-
-    if (!node.left && !node.right) {
-      return [[line], width, 1, Math.floor(width / 2)];
-    }
+    // Check if node is null or undefined or key is NaN
+    if (node === null && !isShowNull) {
+      return emptyDisplayLayout;
+    } else if (node === undefined && !isShowUndefined) {
+      return emptyDisplayLayout;
+    } else if (node !== null && node !== undefined && isNaN(node.key) && !isShowRedBlackNIL) {
+      return emptyDisplayLayout;
+    } else if (node !== null && node !== undefined) {
+      // Display logic of normal nodes
 
-    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 key = node.key, line = isNaN(key) ? 'S' : key.toString(), width = line.length;
 
-    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));
+      return _buildNodeDisplay(line, width, this._displayAux(node.left, options), this._displayAux(node.right, options))
 
-    const secondLine = (leftHeight > 0 ? ' '.repeat(leftMiddle) + '/' + ' '.repeat(leftWidth - leftMiddle - 1) : ' '.repeat(leftWidth))
-      + ' '.repeat(width)
-      + (rightHeight > 0 ? ' '.repeat(rightMiddle) + '\\' + ' '.repeat(rightWidth - rightMiddle - 1) : ' '.repeat(rightWidth));
+    } 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;
 
-    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 _buildNodeDisplay(line, width, [[''], 1, 0, 0], [[''], 1, 0, 0])
     }
 
-    return [mergedLines, leftWidth + width + rightWidth, Math.max(leftHeight, rightHeight) + 2, leftWidth + Math.floor(width / 2)];
+    function _buildNodeDisplay(line: string, width: number, left: NodeDisplayLayout, right: NodeDisplayLayout) {
+      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 <NodeDisplayLayout>[mergedLines, leftWidth + width + rightWidth, Math.max(leftHeight, rightHeight) + 2, leftWidth + Math.floor(width / 2)];
+    }
   }
 
   protected _defaultOneParamCallback = (node: N) => node.key;

package/src/data-structures/binary-tree/bst.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';
@@ -62,9 +62,12 @@ export class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extend
   }
 }
 
-export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>>
-  extends BinaryTree<V, N>
-  implements IBinaryTree<V, N> {
+export 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> {
+
+  override 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
@@ -72,13 +75,12 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    */
   constructor(options?: BSTOptions) {
     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;
   }
 
   protected override _root?: N;
@@ -102,6 +104,10 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     return new BSTNode<V, N>(key, value) as N;
   }
 
+  override createTree(options?: BSTOptions): TREE {
+    return new BST<V, N, TREE>({ ...this.options, ...options }) as 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.
@@ -215,7 +221,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     keysOrNodes: (BTNKey | N | undefined)[],
     data?: (V | undefined)[],
     isBalanceAdd = true,
-    iterationType = this.iterationType
+    iterationType = this.options.iterationType
   ): (N | undefined)[] {
     // TODO this addMany function is inefficient, it should be optimized
     function hasNoUndefined(arr: (BTNKey | N | undefined)[]): arr is (BTNKey | N)[] {
@@ -310,7 +316,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * 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 = this.root, iterationType = this.iterationType): BTNKey {
+  lastKey(beginRoot: BTNKey | N | undefined = this.root, iterationType = this.options.iterationType): BTNKey {
     if (this._compare(0, 1) === CP.lt) return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
     else if (this._compare(0, 1) === CP.gt) return this.getLeftMost(beginRoot, iterationType)?.key ?? 0;
     else return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
@@ -406,7 +412,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     callback: C = this._defaultOneParamCallback as C,
     onlyOne = false,
     beginRoot: BTNKey | N | undefined = this.root,
-    iterationType = this.iterationType
+    iterationType = this.options.iterationType
   ): N[] {
     beginRoot = this.ensureNotKey(beginRoot);
     if (!beginRoot) return [];
@@ -487,7 +493,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     callback: C = this._defaultOneParamCallback as C,
     lesserOrGreater: CP = CP.lt,
     targetNode: BTNKey | N | undefined = this.root,
-    iterationType = this.iterationType
+    iterationType = this.options.iterationType
   ): ReturnType<C>[] {
     targetNode = this.ensureNotKey(targetNode);
     const ans: ReturnType<BTNCallback<N>>[] = [];
@@ -550,7 +556,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * values:
    * @returns The function `perfectlyBalance` returns a boolean value.
    */
-  perfectlyBalance(iterationType = this.iterationType): boolean {
+  perfectlyBalance(iterationType = this.options.iterationType): boolean {
     const sorted = this.dfs(node => node, 'in'),
       n = sorted.length;
     this.clear();
@@ -602,7 +608,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * to check if the AVL tree is balanced. It can have two possible values:
    * @returns a boolean value.
    */
-  isAVLBalanced(iterationType = this.iterationType): boolean {
+  isAVLBalanced(iterationType = this.options.iterationType): boolean {
     if (!this.root) return true;
 
     let balanced = true;
@@ -646,8 +652,6 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     return balanced;
   }
 
-  protected _comparator: BSTComparator = (a, b) => a - b;
-
   protected _setRoot(v: N | undefined) {
     if (v) {
       v.parent = undefined;
@@ -664,7 +668,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * than), CP.lt (less than), or CP.eq (equal).
    */
   protected _compare(a: BTNKey, b: BTNKey): CP {
-    const compared = this._comparator(a, b);
+    const compared = this.options.comparator!(a, b);
     if (compared > 0) return CP.gt;
     else if (compared < 0) return CP.lt;
     else return CP.eq;