data-structure-typed 1.41.1 → 1.41.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.41.1",
+  "version": "1.41.2",
   "description": "Data Structures of Javascript & TypeScript. Binary Tree, BST, Graph, Heap, Priority Queue, Linked List, Queue, Deque, Stack, AVL Tree, Tree Multiset, Trie, Directed Graph, Undirected Graph, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue.",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
@@ -61,17 +61,17 @@
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
     "auto-changelog": "^2.4.0",
-    "avl-tree-typed": "^1.41.0",
+    "avl-tree-typed": "^1.41.1",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.41.0",
-    "bst-typed": "^1.41.0",
+    "binary-tree-typed": "^1.41.1",
+    "bst-typed": "^1.41.1",
     "dependency-cruiser": "^14.1.0",
     "eslint": "^8.50.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-import-resolver-alias": "^1.1.2",
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-import": "^2.28.1",
-    "heap-typed": "^1.41.0",
+    "heap-typed": "^1.41.1",
     "istanbul-badges-readme": "^1.8.5",
     "jest": "^29.7.0",
     "prettier": "^3.0.3",

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;

package/test/integration/avl-tree.test.ts

@@ -12,13 +12,13 @@ describe('AVL Tree Test', () => {
     expect(node6 && tree.getHeight(node6)).toBe(3);
     expect(node6 && tree.getDepth(node6)).toBe(1);
 
-    const getNodeById = tree.get(10);
-    expect(getNodeById?.key).toBe(10);
+    const getValueById = tree.get(10);
+    expect(getValueById).toBe(10);
 
     const getMinNodeByRoot = tree.getLeftMost();
     expect(getMinNodeByRoot?.key).toBe(1);
 
-    const node15 = tree.get(15);
+    const node15 = tree.getNode(15);
     const getMinNodeBySpecificNode = node15 && tree.getLeftMost(node15);
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 

package/test/integration/bst.test.ts

@@ -20,16 +20,16 @@ describe('Individual package BST operations test', () => {
     expect(node6 && bst.getHeight(6)).toBe(2);
     expect(node6 && bst.getDepth(6)).toBe(3);
 
-    const nodeId10 = bst.get(10);
+    const nodeId10 = bst.getNode(10);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = bst.get(9, node => node.value);
+    const nodeVal9 = bst.getNode(9, node => node.value);
     expect(nodeVal9?.key).toBe(9);
 
     const leftMost = bst.getLeftMost();
     expect(leftMost?.key).toBe(1);
 
-    const node15 = bst.get(15);
+    const node15 = bst.getNode(15);
     const minNodeBySpecificNode = node15 && bst.getLeftMost(node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
 
@@ -43,7 +43,7 @@ describe('Individual package BST operations test', () => {
 
     expect(node15).toBeInstanceOf(BSTNode);
 
-    const node11 = bst.get(11);
+    const node11 = bst.getNode(11);
     expect(node11).toBeInstanceOf(BSTNode);
 
     const dfsInorderNodes = bst.dfs(node => node, 'in');
@@ -216,7 +216,7 @@ describe('Individual package BST operations test', () => {
 
     expect(objBST.has(6)).toBe(true);
 
-    const node6 = objBST.get(6);
+    const node6 = objBST.getNode(6);
     expect(node6 && objBST.getHeight(node6)).toBe(2);
     expect(node6 && objBST.getDepth(node6)).toBe(3);
 
@@ -229,7 +229,7 @@ describe('Individual package BST operations test', () => {
     const leftMost = objBST.getLeftMost();
     expect(leftMost?.key).toBe(1);
 
-    const node15 = objBST.get(15);
+    const node15 = objBST.getNode(15);
     expect(node15?.value).toEqual({key: 15, keyA: 15});
     const minNodeBySpecificNode = node15 && objBST.getLeftMost(node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
@@ -244,7 +244,7 @@ describe('Individual package BST operations test', () => {
 
     expect(node15).toBeInstanceOf(BSTNode);
 
-    const node11 = objBST.get(11);
+    const node11 = objBST.getNode(11);
     expect(node11).toBeInstanceOf(BSTNode);
 
     const dfsInorderNodes = objBST.dfs(node => node, 'in');

package/test/unit/data-structures/binary-tree/rb-tree.test.ts

@@ -1,5 +1,8 @@
-import {RBTreeNode, RedBlackTree, SN} from '../../../../src';
+import {RBTNColor, RBTreeNode, RedBlackTree, NIL} from '../../../../src';
 import {getRandomInt} from '../../../utils';
+import {isDebugTest} from '../../../config';
+
+const isDebug = isDebugTest;
 
 describe('RedBlackTree', () => {
   let tree: RedBlackTree;
@@ -63,7 +66,7 @@ describe('RedBlackTree', () => {
 
     test('should handle an empty tree', () => {
       const minNode = tree.getLeftMost(tree.root);
-      expect(minNode).toBe(SN);
+      expect(minNode).toBe(NIL);
     });
   });
 
@@ -81,7 +84,7 @@ describe('RedBlackTree', () => {
 
     test('should handle an empty tree', () => {
       const maxNode = tree.getRightMost(tree.root);
-      expect(maxNode).toBe(SN);
+      expect(maxNode).toBe(NIL);
     });
   });
 
@@ -105,7 +108,7 @@ describe('RedBlackTree', () => {
 
       const node = tree.getNode(10);
       const successorNode = tree.getSuccessor(node);
-      // TODO not sure if it should be null or SN
+      // TODO not sure if it should be null or NIL
       expect(successorNode).toBe(null);
     });
   });
@@ -130,7 +133,7 @@ describe('RedBlackTree', () => {
 
       const node = tree.getNode(20);
       const predecessorNode = tree.getPredecessor(node);
-      // TODO not sure if it should be SN or something else.
+      // TODO not sure if it should be NIL or something else.
       expect(predecessorNode).toBe(tree.getNode(10));
     });
   });
@@ -198,14 +201,146 @@ describe('RedBlackTree', () => {
     expect(node.right.key).toBe(25);
   });
 
-  it('should fix the tree after deletion', () => {
+  it('should all node attributes fully conform to the red-black tree standards.', () => {
     tree.insert(10);
     tree.insert(20);
     tree.insert(5);
     tree.insert(15);
-    tree.delete(15);
-    // Verify that the tree is still valid
-    // You can add assertions to check the Red-Black Tree properties
+    tree.insert(21);
+    tree.insert(6);
+    tree.insert(2);
+
+    let node10F = tree.getNode(10);
+    let node20F = tree.getNode(20);
+    let node5F = tree.getNode(5);
+    let node15F = tree.getNode(15);
+    let node21F = tree.getNode(21);
+    let node6F = tree.getNode(6);
+    let node2F = tree.getNode(2);
+    expect(node10F.key).toBe(10);
+    expect(node10F.color).toBe(RBTNColor.BLACK);
+    expect(node10F.left).toBe(node5F);
+    expect(node10F.right).toBe(node20F);
+    expect(node10F.parent).toBe(null);
+    expect(node20F.key).toBe(20);
+    expect(node20F.color).toBe(RBTNColor.BLACK);
+    expect(node20F.left).toBe(node15F);
+    expect(node20F.right).toBe(node21F);
+    expect(node20F.parent).toBe(node10F);
+    expect(node5F.key).toBe(5);
+    expect(node5F.color).toBe(RBTNColor.BLACK);
+    expect(node5F.left).toBe(node2F);
+    expect(node5F.right).toBe(node6F);
+    expect(node5F.parent).toBe(node10F);
+    expect(node15F.key).toBe(15);
+    expect(node15F.color).toBe(RBTNColor.RED);
+    expect(node15F.left).toBe(NIL);
+    expect(node15F.right).toBe(NIL);
+    expect(node15F.parent).toBe(node20F);
+    expect(node21F.key).toBe(21);
+    expect(node21F.color).toBe(RBTNColor.RED);
+    expect(node21F.left).toBe(NIL);
+    expect(node21F.right).toBe(NIL);
+    expect(node21F.parent).toBe(node20F);
+    expect(node6F.key).toBe(6);
+    expect(node6F.color).toBe(RBTNColor.RED);
+    expect(node6F.left).toBe(NIL);
+    expect(node6F.right).toBe(NIL);
+    expect(node6F.parent).toBe(node5F);
+    expect(node2F.key).toBe(2);
+    expect(node2F.color).toBe(RBTNColor.RED);
+    expect(node2F.left).toBe(NIL);
+    expect(node2F.right).toBe(NIL);
+    expect(node2F.parent).toBe(node5F);
+    expect(node15F.key).toBe(15);
+    expect(node15F.color).toBe(RBTNColor.RED);
+    expect(node15F.left).toBe(NIL);
+    expect(node15F.right).toBe(NIL);
+    expect(node15F.parent).toBe(node20F);
+    tree.delete(5);
+    node10F = tree.getNode(10);
+    node20F = tree.getNode(20);
+    node5F = tree.getNode(5);
+    node15F = tree.getNode(15);
+    node21F = tree.getNode(21);
+    node6F = tree.getNode(6);
+    node2F = tree.getNode(2);
+    expect(node10F.key).toBe(10);
+    expect(node10F.color).toBe(RBTNColor.BLACK);
+    expect(node10F.left).toBe(node6F);
+    expect(node10F.right).toBe(node20F);
+    expect(node10F.parent).toBe(null);
+    expect(node20F.key).toBe(20);
+    expect(node20F.color).toBe(RBTNColor.BLACK);
+    expect(node20F.left).toBe(node15F);
+    expect(node20F.right).toBe(node21F);
+    expect(node20F.parent).toBe(node10F);
+    expect(node5F).toBe(null);
+    expect(node15F.key).toBe(15);
+    expect(node15F.color).toBe(RBTNColor.RED);
+    expect(node15F.left).toBe(NIL);
+    expect(node15F.right).toBe(NIL);
+    expect(node15F.parent).toBe(node20F);
+    expect(node21F.key).toBe(21);
+    expect(node21F.color).toBe(RBTNColor.RED);
+    expect(node21F.left).toBe(NIL);
+    expect(node21F.right).toBe(NIL);
+    expect(node21F.parent).toBe(node20F);
+    expect(node6F.key).toBe(6);
+    expect(node6F.color).toBe(RBTNColor.BLACK);
+    expect(node6F.left).toBe(node2F);
+    expect(node6F.right).toBe(NIL);
+    expect(node6F.parent).toBe(node10F);
+    expect(node2F.key).toBe(2);
+    expect(node2F.color).toBe(RBTNColor.RED);
+    expect(node2F.left).toBe(NIL);
+    expect(node2F.right).toBe(NIL);
+    expect(node2F.parent).toBe(node6F);
+    expect(node15F.key).toBe(15);
+    expect(node15F.color).toBe(RBTNColor.RED);
+    expect(node15F.left).toBe(NIL);
+    expect(node15F.right).toBe(NIL);
+    expect(node15F.parent).toBe(node20F);
+    tree.delete(20);
+    node10F = tree.getNode(10);
+    node20F = tree.getNode(20);
+    node5F = tree.getNode(5);
+    node15F = tree.getNode(15);
+    node21F = tree.getNode(21);
+    node6F = tree.getNode(6);
+    node2F = tree.getNode(2);
+    expect(node10F.key).toBe(10);
+    expect(node10F.color).toBe(RBTNColor.BLACK);
+    expect(node10F.left).toBe(node6F);
+    expect(node10F.right).toBe(node21F);
+    expect(node10F.parent).toBe(null);
+    expect(node20F).toBe(null);
+    expect(node5F).toBe(null);
+    expect(node15F.key).toBe(15);
+    expect(node15F.color).toBe(RBTNColor.RED);
+    expect(node15F.left).toBe(NIL);
+    expect(node15F.right).toBe(NIL);
+    expect(node15F.parent).toBe(node21F);
+    expect(node21F.key).toBe(21);
+    expect(node21F.color).toBe(RBTNColor.BLACK);
+    expect(node21F.left).toBe(node15F);
+    expect(node21F.right).toBe(NIL);
+    expect(node21F.parent).toBe(node10F);
+    expect(node6F.key).toBe(6);
+    expect(node6F.color).toBe(RBTNColor.BLACK);
+    expect(node6F.left).toBe(node2F);
+    expect(node6F.right).toBe(NIL);
+    expect(node6F.parent).toBe(node10F);
+    expect(node2F.key).toBe(2);
+    expect(node2F.color).toBe(RBTNColor.RED);
+    expect(node2F.left).toBe(NIL);
+    expect(node2F.right).toBe(NIL);
+    expect(node2F.parent).toBe(node6F);
+    expect(node15F.key).toBe(15);
+    expect(node15F.color).toBe(RBTNColor.RED);
+    expect(node15F.left).toBe(NIL);
+    expect(node15F.right).toBe(NIL);
+    expect(node15F.parent).toBe(node21F);
   });
 
   it('should fix the tree after insertion', () => {
@@ -214,8 +349,8 @@ describe('RedBlackTree', () => {
     tree.insert(5);
     tree.insert(15);
     const node15F = tree.getNode(15);
-    expect(node15F.left).toBe(SN);
-    expect(node15F.right).toBe(SN);
+    expect(node15F.left).toBe(NIL);
+    expect(node15F.right).toBe(NIL);
     expect(node15F.parent).toBe(tree.getNode(5));
 
     tree.insert(25);
@@ -230,8 +365,8 @@ describe('RedBlackTree', () => {
     tree.insert(155);
     tree.insert(225);
     const node225F = tree.getNode(225);
-    expect(node225F.left).toBe(SN);
-    expect(node225F.right).toBe(SN);
+    expect(node225F.left).toBe(NIL);
+    expect(node225F.right).toBe(NIL);
     expect(node225F.parent.key).toBe(155);
     tree.insert(7);
 
@@ -257,16 +392,38 @@ describe('RedBlackTree', () => {
     const node50 = tree.getNode(50);
     expect(node50.key).toBe(50);
     expect(node50.left.key).toBe(33);
-    expect(node50.right).toBe(SN);
+    expect(node50.right).toBe(NIL);
     const node15Fo = tree.getNode(15);
 
     expect(node15Fo.key).toBe(15);
-    expect(node15Fo.left).toBe(SN);
+    expect(node15Fo.left).toBe(NIL);
     const node225S = tree.getNode(225);
-    expect(node225S.left).toBe(SN);
-    expect(node225S.right).toBe(SN);
+    expect(node225S.left).toBe(NIL);
+    expect(node225S.right).toBe(NIL);
     expect(node225S.parent.key).toBe(155);
     expect(tree.getNode(0)).toBe(null);
+    tree.insert(1);
+    tree.insert(2);
+    tree.insert(3);
+    tree.insert(4);
+    tree.insert(5);
+    tree.insert(6);
+    tree.insert(7);
+    tree.insert(8);
+    tree.insert(9);
+    tree.insert(10);
+    tree.insert(11);
+    tree.insert(12);
+    tree.insert(13);
+    tree.insert(14);
+    tree.insert(15);
+    tree.insert(16);
+    tree.insert(17);
+    tree.insert(18);
+    tree.insert(19);
+    tree.insert(110);
+
+    isDebug && tree.print();
   });
 
   it('should fix the tree after insertion and deletion', () => {