heap-typed 1.46.7 → 1.47.1

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,42 @@ 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>[];
+    /**
+     * 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;
+    /**
+     * 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): TREE;
+    /**
+     * 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): TREE;
+    /**
+     * 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;
     /**
      * 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 +475,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,74 @@ class BinaryTree {
         }
         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) {
+        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) {
+        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) {
+        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(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 +1489,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;
+        }
+        else if (node !== null && node !== undefined && isNaN(node.key) && !isShowRedBlackNIL) {
+            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) {
+            // 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));
         }
-        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 {
+            // 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.