min-heap-typed 1.41.1 → 1.41.2

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

@@ -174,15 +174,15 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
     getNodes<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
     getNodes<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
     getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
-    has<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N, iterationType?: IterationType): boolean;
-    has<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, beginRoot?: N, iterationType?: IterationType): boolean;
-    has<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C, beginRoot?: N, iterationType?: IterationType): boolean;
-    getNode<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N, iterationType?: IterationType): N | null;
-    getNode<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, beginRoot?: N, iterationType?: IterationType): N | null;
-    getNode<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: N, iterationType?: IterationType): N | null;
-    get<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N, iterationType?: IterationType): V | undefined;
-    get<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, beginRoot?: N, iterationType?: IterationType): V | undefined;
-    get<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: N, iterationType?: IterationType): V | undefined;
+    has<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N | null, iterationType?: IterationType): boolean;
+    has<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, beginRoot?: N | null, iterationType?: IterationType): boolean;
+    has<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C, beginRoot?: N | null, iterationType?: IterationType): boolean;
+    getNode<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N | null, iterationType?: IterationType): N | null;
+    getNode<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, beginRoot?: N | null, iterationType?: IterationType): N | null;
+    getNode<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: N | null, iterationType?: IterationType): N | null;
+    get<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N | null, iterationType?: IterationType): V | undefined;
+    get<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, beginRoot?: N | null, iterationType?: IterationType): V | undefined;
+    get<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: N | null, iterationType?: IterationType): V | undefined;
     /**
      * The function `getPathToRoot` returns an array of nodes starting from a given node and traversing
      * up to the root node, with the option to reverse the order of the nodes.

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

@@ -503,7 +503,6 @@ class BinaryTree {
     has(identifier, callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
         if (identifier instanceof BinaryTreeNode)
             callback = (node => node);
-        // TODO may support finding node by value equal
         return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
     }
     /**
@@ -525,7 +524,6 @@ class BinaryTree {
         var _a;
         if (identifier instanceof BinaryTreeNode)
             callback = (node => node);
-        // TODO may support finding node by value equal
         return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : null;
     }
     /**
@@ -544,11 +542,10 @@ class BinaryTree {
      * @returns either the found value (of type V) or undefined if no node value is found.
      */
     get(identifier, callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
-        var _a;
+        var _a, _b;
         if (identifier instanceof BinaryTreeNode)
             callback = (node => node);
-        // TODO may support finding node by value equal
-        return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0].value) !== null && _a !== void 0 ? _a : undefined;
+        return (_b = (_a = this.getNode(identifier, callback, beginRoot, iterationType)) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : undefined;
     }
     /**
      * The function `getPathToRoot` returns an array of nodes starting from a given node and traversing

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

@@ -1,3 +1,10 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
 import { RBTNColor } from '../../types';
 export declare class RBTreeNode {
     key: number;
@@ -7,7 +14,14 @@ export declare class RBTreeNode {
     color: number;
     constructor(key: number, color?: RBTNColor);
 }
-export declare const SN: RBTreeNode;
+export declare const NIL: RBTreeNode;
+/**
+ * 1. Each node is either red or black.
+ * 2. The root node is always black.
+ * 3. Leaf nodes are typically NIL nodes and are considered black.
+ * 4. Red nodes must have black children.
+ * 5. Black balance: Every path from any node to each of its leaf nodes contains the same number of black nodes.
+ */
 export declare class RedBlackTree {
     constructor();
     protected _root: RBTreeNode;
@@ -28,7 +42,7 @@ export declare class RedBlackTree {
      * @returns The `delete` function does not return anything. It has a return type of `void`.
      */
     delete(key: number): void;
-    isRealNode(node: RBTreeNode): node is RBTreeNode;
+    isRealNode(node: RBTreeNode | null | undefined): node is RBTreeNode;
     /**
      * The function `getNode` is a recursive depth-first search algorithm that searches for a node with a
      * given key in a red-black tree.
@@ -66,6 +80,7 @@ export declare class RedBlackTree {
      * @returns the predecessor of the given RBTreeNode 'x'.
      */
     getPredecessor(x: RBTreeNode): RBTreeNode;
+    print(beginRoot?: RBTreeNode): void;
     /**
      * The function performs a left rotation on a red-black tree node.
      * @param {RBTreeNode} x - The parameter `x` is a RBTreeNode object.

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

@@ -1,6 +1,13 @@
 "use strict";
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedBlackTree = exports.SN = exports.RBTreeNode = void 0;
+exports.RedBlackTree = exports.NIL = exports.RBTreeNode = void 0;
 const types_1 = require("../../types");
 class RBTreeNode {
     constructor(key, color = types_1.RBTNColor.BLACK) {
@@ -13,10 +20,17 @@ class RBTreeNode {
     }
 }
 exports.RBTreeNode = RBTreeNode;
-exports.SN = new RBTreeNode(0);
+exports.NIL = new RBTreeNode(0);
+/**
+ * 1. Each node is either red or black.
+ * 2. The root node is always black.
+ * 3. Leaf nodes are typically NIL nodes and are considered black.
+ * 4. Red nodes must have black children.
+ * 5. Black balance: Every path from any node to each of its leaf nodes contains the same number of black nodes.
+ */
 class RedBlackTree {
     constructor() {
-        this._root = exports.SN;
+        this._root = exports.NIL;
     }
     get root() {
         return this._root;
@@ -30,11 +44,11 @@ class RedBlackTree {
      */
     insert(key) {
         const node = new RBTreeNode(key, types_1.RBTNColor.RED);
-        node.left = exports.SN;
-        node.right = exports.SN;
+        node.left = exports.NIL;
+        node.right = exports.NIL;
         let y = null;
         let x = this.root;
-        while (x !== exports.SN) {
+        while (x !== exports.NIL) {
             y = x;
             if (node.key < x.key) {
                 x = x.left;
@@ -71,9 +85,9 @@ class RedBlackTree {
      */
     delete(key) {
         const helper = (node) => {
-            let z = exports.SN;
+            let z = exports.NIL;
             let x, y;
-            while (node !== exports.SN) {
+            while (node !== exports.NIL) {
                 if (node.key === key) {
                     z = node;
                 }
@@ -84,16 +98,16 @@ class RedBlackTree {
                     node = node.left;
                 }
             }
-            if (z === exports.SN) {
+            if (z === exports.NIL) {
                 return;
             }
             y = z;
             let yOriginalColor = y.color;
-            if (z.left === exports.SN) {
+            if (z.left === exports.NIL) {
                 x = z.right;
                 this._rbTransplant(z, z.right);
             }
-            else if (z.right === exports.SN) {
+            else if (z.right === exports.NIL) {
                 x = z.left;
                 this._rbTransplant(z, z.left);
             }
@@ -121,7 +135,7 @@ class RedBlackTree {
         helper(this.root);
     }
     isRealNode(node) {
-        return node !== exports.SN && node !== null;
+        return node !== exports.NIL && node !== null;
     }
     /**
      * The function `getNode` is a recursive depth-first search algorithm that searches for a node with a
@@ -156,7 +170,7 @@ class RedBlackTree {
      * @returns The leftmost node in the given RBTreeNode.
      */
     getLeftMost(node = this.root) {
-        while (node.left !== null && node.left !== exports.SN) {
+        while (node.left !== null && node.left !== exports.NIL) {
             node = node.left;
         }
         return node;
@@ -167,7 +181,7 @@ class RedBlackTree {
      * @returns the rightmost node in a red-black tree.
      */
     getRightMost(node) {
-        while (node.right !== null && node.right !== exports.SN) {
+        while (node.right !== null && node.right !== exports.NIL) {
             node = node.right;
         }
         return node;
@@ -178,11 +192,11 @@ class RedBlackTree {
      * @returns the successor of the given RBTreeNode.
      */
     getSuccessor(x) {
-        if (x.right !== exports.SN) {
+        if (x.right !== exports.NIL) {
             return this.getLeftMost(x.right);
         }
         let y = x.parent;
-        while (y !== exports.SN && y !== null && x === y.right) {
+        while (y !== exports.NIL && y !== null && x === y.right) {
             x = y;
             y = y.parent;
         }
@@ -195,16 +209,69 @@ class RedBlackTree {
      * @returns the predecessor of the given RBTreeNode 'x'.
      */
     getPredecessor(x) {
-        if (x.left !== exports.SN) {
+        if (x.left !== exports.NIL) {
             return this.getRightMost(x.left);
         }
         let y = x.parent;
-        while (y !== exports.SN && x === y.left) {
+        while (y !== exports.NIL && x === y.left) {
             x = y;
             y = y.parent;
         }
         return y;
     }
+    print(beginRoot = this.root) {
+        const display = (root) => {
+            const [lines, , ,] = _displayAux(root);
+            for (const line of lines) {
+                console.log(line);
+            }
+        };
+        const _displayAux = (node) => {
+            if (node === null) {
+                return [[], 0, 0, 0];
+            }
+            if (node.right === null && node.left === null) {
+                const line = `${node.key}`;
+                const width = line.length;
+                const height = 1;
+                const middle = Math.floor(width / 2);
+                return [[line], width, height, middle];
+            }
+            if (node.right === null) {
+                const [lines, n, p, x] = _displayAux(node.left);
+                const s = `${node.key}`;
+                const u = s.length;
+                const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s;
+                const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u);
+                const shifted_lines = lines.map(line => line + ' '.repeat(u));
+                return [[first_line, second_line, ...shifted_lines], n + u, p + 2, n + Math.floor(u / 2)];
+            }
+            if (node.left === null) {
+                const [lines, n, p, u] = _displayAux(node.right);
+                const s = `${node.key}`;
+                const x = s.length;
+                const first_line = s + '_'.repeat(x) + ' '.repeat(n - x);
+                const second_line = ' '.repeat(u + x) + '\\' + ' '.repeat(n - x - 1);
+                const shifted_lines = lines.map(line => ' '.repeat(u) + line);
+                return [[first_line, second_line, ...shifted_lines], n + x, p + 2, Math.floor(u / 2)];
+            }
+            const [left, n, p, x] = _displayAux(node.left);
+            const [right, m, q, y] = _displayAux(node.right);
+            const s = `${node.key}`;
+            const u = s.length;
+            const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s + '_'.repeat(y) + ' '.repeat(m - y);
+            const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u + y) + '\\' + ' '.repeat(m - y - 1);
+            if (p < q) {
+                left.push(...new Array(q - p).fill(' '.repeat(n)));
+            }
+            else if (q < p) {
+                right.push(...new Array(p - q).fill(' '.repeat(m)));
+            }
+            const zipped_lines = left.map((a, i) => a + ' '.repeat(u) + right[i]);
+            return [[first_line, second_line, ...zipped_lines], n + m + u, Math.max(p, q) + 2, n + Math.floor(u / 2)];
+        };
+        display(beginRoot);
+    }
     /**
      * The function performs a left rotation on a red-black tree node.
      * @param {RBTreeNode} x - The parameter `x` is a RBTreeNode object.
@@ -212,7 +279,7 @@ class RedBlackTree {
     _leftRotate(x) {
         const y = x.right;
         x.right = y.left;
-        if (y.left !== exports.SN) {
+        if (y.left !== exports.NIL) {
             y.left.parent = x;
         }
         y.parent = x.parent;
@@ -236,7 +303,7 @@ class RedBlackTree {
     _rightRotate(x) {
         const y = x.left;
         x.left = y.right;
-        if (y.right !== exports.SN) {
+        if (y.right !== exports.NIL) {
             y.right.parent = x;
         }
         y.parent = x.parent;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "min-heap-typed",
-  "version": "1.41.1",
+  "version": "1.41.2",
   "description": "Min Heap. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -131,6 +131,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.41.1"
+    "data-structure-typed": "^1.41.2"
   }
 }

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

@@ -559,21 +559,21 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
   has<C extends BTNCallback<N, BTNKey>>(
     identifier: BTNKey,
     callback?: C,
-    beginRoot?: N,
+    beginRoot?: N | null,
     iterationType?: IterationType
   ): boolean;
 
   has<C extends BTNCallback<N, N>>(
     identifier: N | null,
     callback?: C,
-    beginRoot?: N,
+    beginRoot?: N | null,
     iterationType?: IterationType
   ): boolean;
 
   has<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
     callback: C,
-    beginRoot?: N,
+    beginRoot?: N | null,
     iterationType?: IterationType
   ): boolean;
 
@@ -601,28 +601,28 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     iterationType = this.iterationType
   ): boolean {
     if ((identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
-    // TODO may support finding node by value equal
+
     return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
   }
 
   getNode<C extends BTNCallback<N, BTNKey>>(
     identifier: BTNKey,
     callback?: C,
-    beginRoot?: N,
+    beginRoot?: N | null,
     iterationType?: IterationType
   ): N | null;
 
   getNode<C extends BTNCallback<N, N>>(
     identifier: N | null,
     callback?: C,
-    beginRoot?: N,
+    beginRoot?: N | null,
     iterationType?: IterationType
   ): N | null;
 
   getNode<C extends BTNCallback<N>>(
     identifier: ReturnType<C>,
     callback: C,
-    beginRoot?: N,
+    beginRoot?: N | null,
     iterationType?: IterationType
   ): N | null;
 
@@ -648,28 +648,28 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     iterationType = this.iterationType
   ): N | null {
     if ((identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
-    // TODO may support finding node by value equal
+
     return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? null;
   }
 
   get<C extends BTNCallback<N, BTNKey>>(
     identifier: BTNKey,
     callback?: C,
-    beginRoot?: N,
+    beginRoot?: N | null,
     iterationType?: IterationType
   ): V | undefined;
 
   get<C extends BTNCallback<N, N>>(
     identifier: N | null,
     callback?: C,
-    beginRoot?: N,
+    beginRoot?: N | null,
     iterationType?: IterationType
   ): V | undefined;
 
   get<C extends BTNCallback<N>>(
     identifier: ReturnType<C>,
     callback: C,
-    beginRoot?: N,
+    beginRoot?: N | null,
     iterationType?: IterationType
   ): V | undefined;
 
@@ -695,8 +695,8 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     iterationType = this.iterationType
   ): V | undefined {
     if ((identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
-    // TODO may support finding node by value equal
-    return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0].value ?? undefined;
+
+    return this.getNode(identifier, callback, beginRoot, iterationType)?.value ?? undefined;
   }
 
   /**

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

@@ -1,3 +1,11 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+
 import {RBTNColor} from '../../types';
 
 export class RBTreeNode {
@@ -16,11 +24,18 @@ export class RBTreeNode {
   }
 }
 
-export const SN = new RBTreeNode(0);
+export const NIL = new RBTreeNode(0);
 
+/**
+ * 1. Each node is either red or black.
+ * 2. The root node is always black.
+ * 3. Leaf nodes are typically NIL nodes and are considered black.
+ * 4. Red nodes must have black children.
+ * 5. Black balance: Every path from any node to each of its leaf nodes contains the same number of black nodes.
+ */
 export class RedBlackTree {
   constructor() {
-    this._root = SN;
+    this._root = NIL;
   }
 
   protected _root: RBTreeNode;
@@ -38,13 +53,13 @@ export class RedBlackTree {
    */
   insert(key: number): void {
     const node: RBTreeNode = new RBTreeNode(key, RBTNColor.RED);
-    node.left = SN;
-    node.right = SN;
+    node.left = NIL;
+    node.right = NIL;
 
     let y: RBTreeNode = null as unknown as RBTreeNode;
     let x: RBTreeNode = this.root;
 
-    while (x !== SN) {
+    while (x !== NIL) {
       y = x;
       if (node.key < x.key) {
         x = x.left;
@@ -83,9 +98,9 @@ export class RedBlackTree {
    */
   delete(key: number): void {
     const helper = (node: RBTreeNode): void => {
-      let z: RBTreeNode = SN;
+      let z: RBTreeNode = NIL;
       let x: RBTreeNode, y: RBTreeNode;
-      while (node !== SN) {
+      while (node !== NIL) {
         if (node.key === key) {
           z = node;
         }
@@ -97,16 +112,16 @@ export class RedBlackTree {
         }
       }
 
-      if (z === SN) {
+      if (z === NIL) {
         return;
       }
 
       y = z;
       let yOriginalColor: number = y.color;
-      if (z.left === SN) {
+      if (z.left === NIL) {
         x = z.right;
         this._rbTransplant(z, z.right);
-      } else if (z.right === SN) {
+      } else if (z.right === NIL) {
         x = z.left;
         this._rbTransplant(z, z.left);
       } else {
@@ -133,8 +148,8 @@ export class RedBlackTree {
     helper(this.root);
   }
 
-  isRealNode(node: RBTreeNode): node is RBTreeNode {
-    return node !== SN && node !== null;
+  isRealNode(node: RBTreeNode | null | undefined): node is RBTreeNode {
+    return node !== NIL && node !== null;
   }
 
   /**
@@ -170,7 +185,7 @@ export class RedBlackTree {
    * @returns The leftmost node in the given RBTreeNode.
    */
   getLeftMost(node: RBTreeNode = this.root): RBTreeNode {
-    while (node.left !== null && node.left !== SN) {
+    while (node.left !== null && node.left !== NIL) {
       node = node.left;
     }
     return node;
@@ -182,7 +197,7 @@ export class RedBlackTree {
    * @returns the rightmost node in a red-black tree.
    */
   getRightMost(node: RBTreeNode): RBTreeNode {
-    while (node.right !== null && node.right !== SN) {
+    while (node.right !== null && node.right !== NIL) {
       node = node.right;
     }
     return node;
@@ -194,12 +209,12 @@ export class RedBlackTree {
    * @returns the successor of the given RBTreeNode.
    */
   getSuccessor(x: RBTreeNode): RBTreeNode {
-    if (x.right !== SN) {
+    if (x.right !== NIL) {
       return this.getLeftMost(x.right);
     }
 
     let y: RBTreeNode = x.parent;
-    while (y !== SN && y !== null && x === y.right) {
+    while (y !== NIL && y !== null && x === y.right) {
       x = y;
       y = y.parent;
     }
@@ -213,12 +228,12 @@ export class RedBlackTree {
    * @returns the predecessor of the given RBTreeNode 'x'.
    */
   getPredecessor(x: RBTreeNode): RBTreeNode {
-    if (x.left !== SN) {
+    if (x.left !== NIL) {
       return this.getRightMost(x.left);
     }
 
     let y: RBTreeNode = x.parent;
-    while (y !== SN && x === y.left) {
+    while (y !== NIL && x === y.left) {
       x = y;
       y = y.parent;
     }
@@ -226,6 +241,65 @@ export class RedBlackTree {
     return y;
   }
 
+  print(beginRoot: RBTreeNode = this.root) {
+    const display = (root: RBTreeNode | null): void => {
+      const [lines, , ,] = _displayAux(root);
+      for (const line of lines) {
+        console.log(line);
+      }
+    };
+
+    const _displayAux = (node: RBTreeNode | null): [string[], number, number, number] => {
+      if (node === null) {
+        return [[], 0, 0, 0];
+      }
+
+      if (node.right === null && node.left === null) {
+        const line = `${node.key}`;
+        const width = line.length;
+        const height = 1;
+        const middle = Math.floor(width / 2);
+        return [[line], width, height, middle];
+      }
+
+      if (node.right === null) {
+        const [lines, n, p, x] = _displayAux(node.left);
+        const s = `${node.key}`;
+        const u = s.length;
+        const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s;
+        const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u);
+        const shifted_lines = lines.map(line => line + ' '.repeat(u));
+        return [[first_line, second_line, ...shifted_lines], n + u, p + 2, n + Math.floor(u / 2)];
+      }
+
+      if (node.left === null) {
+        const [lines, n, p, u] = _displayAux(node.right);
+        const s = `${node.key}`;
+        const x = s.length;
+        const first_line = s + '_'.repeat(x) + ' '.repeat(n - x);
+        const second_line = ' '.repeat(u + x) + '\\' + ' '.repeat(n - x - 1);
+        const shifted_lines = lines.map(line => ' '.repeat(u) + line);
+        return [[first_line, second_line, ...shifted_lines], n + x, p + 2, Math.floor(u / 2)];
+      }
+
+      const [left, n, p, x] = _displayAux(node.left);
+      const [right, m, q, y] = _displayAux(node.right);
+      const s = `${node.key}`;
+      const u = s.length;
+      const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s + '_'.repeat(y) + ' '.repeat(m - y);
+      const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u + y) + '\\' + ' '.repeat(m - y - 1);
+      if (p < q) {
+        left.push(...new Array(q - p).fill(' '.repeat(n)));
+      } else if (q < p) {
+        right.push(...new Array(p - q).fill(' '.repeat(m)));
+      }
+      const zipped_lines = left.map((a, i) => a + ' '.repeat(u) + right[i]);
+      return [[first_line, second_line, ...zipped_lines], n + m + u, Math.max(p, q) + 2, n + Math.floor(u / 2)];
+    };
+
+    display(beginRoot);
+  }
+
   /**
    * The function performs a left rotation on a red-black tree node.
    * @param {RBTreeNode} x - The parameter `x` is a RBTreeNode object.
@@ -233,7 +307,7 @@ export class RedBlackTree {
   protected _leftRotate(x: RBTreeNode): void {
     const y: RBTreeNode = x.right;
     x.right = y.left;
-    if (y.left !== SN) {
+    if (y.left !== NIL) {
       y.left.parent = x;
     }
     y.parent = x.parent;
@@ -256,7 +330,7 @@ export class RedBlackTree {
   protected _rightRotate(x: RBTreeNode): void {
     const y: RBTreeNode = x.left;
     x.left = y.right;
-    if (y.right !== SN) {
+    if (y.right !== NIL) {
       y.right.parent = x;
     }
     y.parent = x.parent;