data-structure-typed 1.51.1 → 1.51.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.51.1",
+  "version": "1.51.2",
   "description": "Javascript Data Structure. Heap, Binary Tree, Red Black Tree, Linked List, Deque, Trie, HashMap, Directed Graph, Undirected Graph, Binary Search Tree(BST), AVL Tree, Priority Queue, Graph, Queue, Tree Multiset, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue, Stack. Benchmark compared with C++ STL. API aligned with ES6 and Java.util. Usability is comparable to Python",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
@@ -66,11 +66,11 @@
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
     "auto-changelog": "^2.4.0",
-    "avl-tree-typed": "^1.51.0",
+    "avl-tree-typed": "^1.51.1",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.51.0",
-    "bst-typed": "^1.51.0",
-    "data-structure-typed": "^1.51.0",
+    "binary-tree-typed": "^1.51.1",
+    "bst-typed": "^1.51.1",
+    "data-structure-typed": "^1.51.1",
     "dependency-cruiser": "^14.1.0",
     "doctoc": "^2.2.1",
     "eslint": "^8.50.0",
@@ -79,7 +79,7 @@
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-import": "^2.28.1",
     "fast-glob": "^3.3.1",
-    "heap-typed": "^1.51.0",
+    "heap-typed": "^1.51.1",
     "istanbul-badges-readme": "^1.8.5",
     "jest": "^29.7.0",
     "js-sdsl": "^4.4.2",

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

@@ -191,6 +191,16 @@ export class BinaryTree<
     return this._size;
   }
 
+  protected _NIL: NODE = new BinaryTreeNode<K, V>(NaN as K) as unknown as NODE;
+
+  /**
+   * The function returns the value of the _NIL property.
+   * @returns The method is returning the value of the `_NIL` property.
+   */
+  get NIL(): NODE {
+    return this._NIL;
+  }
+
   /**
    * Creates a new instance of BinaryTreeNode with the given key and value.
    * @param {K} key - The key for the new node.
@@ -281,6 +291,15 @@ export class BinaryTree<
     }
   }
 
+  /**
+   * The function checks if a given node is a real node or null.
+   * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+   * @returns a boolean value.
+   */
+  isNodeOrNull(node: KeyOrNodeOrEntry<K, V, NODE>): node is NODE | null {
+    return this.isRealNode(node) || node === null;
+  }
+
   /**
    * The function "isNode" checks if an keyOrNodeOrEntry is an instance of the BinaryTreeNode class.
    * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V,NODE>`.
@@ -290,16 +309,6 @@ export class BinaryTree<
     return keyOrNodeOrEntry instanceof BinaryTreeNode;
   }
 
-  /**
-   * The function checks if a given value is an entry in a binary tree node.
-   * @param keyOrNodeOrEntry - KeyOrNodeOrEntry<K, V,NODE> - A generic type representing a node in a binary tree. It has
-   * two type parameters V and NODE, representing the value and node type respectively.
-   * @returns a boolean value.
-   */
-  isEntry(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntry is BTNEntry<K, V> {
-    return Array.isArray(keyOrNodeOrEntry) && keyOrNodeOrEntry.length === 2;
-  }
-
   /**
    * The function checks if a given node is a real node by verifying if it is an instance of
    * BinaryTreeNode and its key is not NaN.
@@ -307,7 +316,8 @@ export class BinaryTree<
    * @returns a boolean value.
    */
   isRealNode(node: KeyOrNodeOrEntry<K, V, NODE>): node is NODE {
-    return node instanceof BinaryTreeNode && String(node.key) !== 'NaN';
+    if (!this.isNode(node)) return false;
+    return node !== this.NIL;
   }
 
   /**
@@ -316,16 +326,17 @@ export class BinaryTree<
    * @returns a boolean value.
    */
   isNIL(node: KeyOrNodeOrEntry<K, V, NODE>) {
-    return node instanceof BinaryTreeNode && String(node.key) === 'NaN';
+    return node === this.NIL;
   }
 
   /**
-   * The function checks if a given node is a real node or null.
-   * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+   * The function checks if a given value is an entry in a binary tree node.
+   * @param keyOrNodeOrEntry - KeyOrNodeOrEntry<K, V,NODE> - A generic type representing a node in a binary tree. It has
+   * two type parameters V and NODE, representing the value and node type respectively.
    * @returns a boolean value.
    */
-  isNodeOrNull(node: KeyOrNodeOrEntry<K, V, NODE>): node is NODE | null {
-    return this.isRealNode(node) || node === null;
+  isEntry(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntry is BTNEntry<K, V> {
+    return Array.isArray(keyOrNodeOrEntry) && keyOrNodeOrEntry.length === 2;
   }
 
   /**
@@ -612,9 +623,9 @@ export class BinaryTree<
           ans.push(cur);
           if (onlyOne) return;
         }
-        if (!cur.left && !cur.right) return;
-        cur.left && dfs(cur.left);
-        cur.right && dfs(cur.right);
+        if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
+        this.isRealNode(cur.left) && dfs(cur.left);
+        this.isRealNode(cur.right) && dfs(cur.right);
       };
 
       dfs(beginRoot);
@@ -622,13 +633,13 @@ export class BinaryTree<
       const stack = [beginRoot];
       while (stack.length > 0) {
         const cur = stack.pop();
-        if (cur) {
+        if (this.isRealNode(cur)) {
           if (callback(cur) === identifier) {
             ans.push(cur);
             if (onlyOne) return ans;
           }
-          cur.left && stack.push(cur.left);
-          cur.right && stack.push(cur.right);
+          this.isRealNode(cur.left) && stack.push(cur.left);
+          this.isRealNode(cur.right) && stack.push(cur.right);
         }
       }
     }
@@ -689,9 +700,6 @@ export class BinaryTree<
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): NODE | null | undefined {
-    if ((!callback || callback === this._DEFAULT_CALLBACK) && (identifier as any) instanceof BinaryTreeNode)
-      callback = (node => node) as C;
-
     return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? null;
   }
 
@@ -793,9 +801,6 @@ export class BinaryTree<
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): V | undefined {
-    if ((!callback || callback === this._DEFAULT_CALLBACK) && (identifier as any) instanceof BinaryTreeNode)
-      callback = (node => node) as C;
-
     return this.getNode(identifier, callback, beginRoot, iterationType)?.value ?? undefined;
   }
 

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

@@ -13,7 +13,7 @@ import type {
   BTNodePureExemplar,
   KeyOrNodeOrEntry
 } from '../../types';
-import { BSTVariant, CP, DFSOrderPattern, IterationType } from '../../types';
+import { BSTNKeyOrNode, BSTVariant, CP, DFSOrderPattern, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 import { Queue } from '../queue';
@@ -543,6 +543,41 @@ export class BST<
     return ans;
   }
 
+  /**
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
+   *
+   * The `getNode` function retrieves a node from a Red-Black Tree based on the provided identifier and
+   * callback function.
+   * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value or key
+   * that you want to search for in the binary search tree. It can be of any type that is compatible
+   * with the type of nodes in the tree.
+   * @param {C} callback - The `callback` parameter is a function that will be called for each node in
+   * the tree. It is used to determine whether a node matches the given identifier. The `callback`
+   * function should take a node as its parameter and return a value that can be compared to the
+   * `identifier` parameter.
+   * @param beginRoot - The `beginRoot` parameter is the starting point for the search in the binary
+   * search tree. It can be either a key or a node. If it is a key, it will be converted to a node
+   * using the `ensureNode` method. If it is not provided, the `root`
+   * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+   * be performed when searching for nodes in the binary search tree. It is an optional parameter and
+   * its default value is taken from the `iterationType` property of the class.
+   * @returns The method is returning a value of type `NODE | null | undefined`.
+   */
+  override getNode<C extends BTNCallback<NODE>>(
+    identifier: ReturnType<C> | undefined,
+    callback: C = this._DEFAULT_CALLBACK as C,
+    beginRoot: BSTNKeyOrNode<K, NODE> = this.root,
+    iterationType: IterationType = this.iterationType
+  ): NODE | undefined {
+    return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
+  }
+
   /**
    * Time complexity: O(n)
    * Space complexity: O(n)

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

@@ -1,8 +1,6 @@
 import type {
   BinaryTreeDeleteResult,
-  BSTNKeyOrNode,
   BTNCallback,
-  IterationType,
   KeyOrNodeOrEntry,
   RBTreeOptions,
   RedBlackTreeNested,
@@ -73,23 +71,13 @@ export class RedBlackTree<
   constructor(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, NODE>> = [], options?: RBTreeOptions<K>) {
     super([], options);
 
-    this._root = this.SENTINEL;
+    this._root = this.NIL;
 
     if (keysOrNodesOrEntries) {
       this.addMany(keysOrNodesOrEntries);
     }
   }
 
-  protected _SENTINEL: NODE = new RedBlackTreeNode<K, V>(NaN as K) as unknown as NODE;
-
-  /**
-   * The function returns the value of the _SENTINEL property.
-   * @returns The method is returning the value of the `_SENTINEL` property.
-   */
-  get SENTINEL(): NODE {
-    return this._SENTINEL;
-  }
-
   protected override _root: NODE | undefined;
 
   /**
@@ -184,60 +172,6 @@ export class RedBlackTree<
     return keyOrNodeOrEntry instanceof RedBlackTreeNode;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function checks if a given node is a real node in a Red-Black Tree.
-   * @param {NODE | undefined} node - The `node` parameter is of type `NODE | undefined`, which means
-   * it can either be of type `NODE` or `undefined`.
-   * @returns a boolean value.
-   */
-  override isRealNode(node: NODE | undefined): node is NODE {
-    if (node === this.SENTINEL || node === undefined) return false;
-    return node instanceof RedBlackTreeNode;
-  }
-
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   *
-   * The `getNode` function retrieves a node from a Red-Black Tree based on the provided identifier and
-   * callback function.
-   * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value or key
-   * that you want to search for in the binary search tree. It can be of any type that is compatible
-   * with the type of nodes in the tree.
-   * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-   * the tree. It is used to determine whether a node matches the given identifier. The `callback`
-   * function should take a node as its parameter and return a value that can be compared to the
-   * `identifier` parameter.
-   * @param beginRoot - The `beginRoot` parameter is the starting point for the search in the binary
-   * search tree. It can be either a key or a node. If it is a key, it will be converted to a node
-   * using the `ensureNode` method. If it is not provided, the `root`
-   * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
-   * be performed when searching for nodes in the binary search tree. It is an optional parameter and
-   * its default value is taken from the `iterationType` property of the class.
-   * @returns The method is returning a value of type `NODE | null | undefined`.
-   */
-  override getNode<C extends BTNCallback<NODE>>(
-    identifier: ReturnType<C> | undefined,
-    callback: C = this._DEFAULT_CALLBACK as C,
-    beginRoot: BSTNKeyOrNode<K, NODE> = this.root,
-    iterationType: IterationType = this.iterationType
-  ): NODE | null | undefined {
-    return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
-  }
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -252,7 +186,7 @@ export class RedBlackTree<
    */
   override clear() {
     super.clear();
-    this._root = this.SENTINEL;
+    this._root = this.NIL;
   }
 
   /**
@@ -430,9 +364,9 @@ export class RedBlackTree<
     while (this.isRealNode(current)) {
       parent = current;
       if (node.key < current.key) {
-        current = current.left ?? this.SENTINEL;
+        current = current.left ?? this.NIL;
       } else if (node.key > current.key) {
-        current = current.right ?? this.SENTINEL;
+        current = current.right ?? this.NIL;
       } else {
         this._replaceNode(current, node);
         return 'UPDATED';
@@ -449,8 +383,8 @@ export class RedBlackTree<
       parent.right = node;
     }
 
-    node.left = this.SENTINEL;
-    node.right = this.SENTINEL;
+    node.left = this.NIL;
+    node.right = this.NIL;
     node.color = 'RED';
 
     this._insertFixup(node);

package/test/performance/data-structures/binary-tree/avl-tree.test.ts

@@ -12,6 +12,10 @@ suite
     avlTree.clear();
     for (let i = 0; i < randomArray.length; i++) avlTree.add(i);
   })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add randomly`, () => {
+    avlTree.clear();
+    for (let i = 0; i < randomArray.length; i++) avlTree.add(randomArray[i]);
+  })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} get`, () => {
     for (let i = 0; i < randomArray.length; i++) avlTree.get(randomArray[i]);
   })

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

@@ -15,6 +15,10 @@ suite
     rbTree.clear();
     for (let i = 0; i < randomArray.length; i++) rbTree.add(i);
   })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add randomly`, () => {
+    rbTree.clear();
+    for (let i = 0; i < randomArray.length; i++) rbTree.add(randomArray[i]);
+  })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} get`, () => {
     for (let i = 0; i < randomArray.length; i++) rbTree.get(randomArray[i]);
   })

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

@@ -20,8 +20,8 @@ describe('Overall BinaryTree Test', () => {
     leftMost?.key === 1; // true
     expect(leftMost?.key).toBe(1);
     bst.delete(6);
-    bst.getNode(6); // null
-    expect(bst.getNode(6)).toBeNull();
+    bst.getNode(6); // undefined
+    expect(bst.getNode(6)).toBe(undefined);
     bst.isAVLBalanced(); // true or false
     expect(bst.isAVLBalanced()).toBe(true);
     const bfsIDs: number[] = [];

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

@@ -74,7 +74,7 @@ describe('RedBlackTree 1', () => {
 
     it('should handle an empty rbTree', () => {
       const minNode = rbTree.getLeftMost(rbTree.root);
-      expect(minNode).toBe(rbTree.SENTINEL);
+      expect(minNode).toBe(rbTree.NIL);
     });
   });
 
@@ -92,7 +92,7 @@ describe('RedBlackTree 1', () => {
 
     it('should handle an empty rbTree', () => {
       const maxNode = rbTree.getRightMost(rbTree.root);
-      expect(maxNode).toBe(rbTree.SENTINEL);
+      expect(maxNode).toBe(rbTree.NIL);
     });
   });
 
@@ -116,7 +116,7 @@ describe('RedBlackTree 1', () => {
 
       const node = rbTree.getNode(10);
       const successorNode = rbTree.getSuccessor(node!);
-      // TODO not sure if it should be undefined or rbTree.SENTINEL
+      // TODO not sure if it should be undefined or rbTree.NIL
       expect(successorNode).toBe(undefined);
     });
   });
@@ -141,7 +141,7 @@ describe('RedBlackTree 1', () => {
 
       const node = rbTree.getNode(20);
       const predecessorNode = rbTree.getPredecessor(node!);
-      // TODO not sure if it should be rbTree.SENTINEL or something else.
+      // TODO not sure if it should be rbTree.NIL or something else.
       expect(predecessorNode).toBe(rbTree.getNode(20));
     });
   });
@@ -279,28 +279,28 @@ describe('RedBlackTree 2', () => {
     expect(node5F?.parent).toBe(node10F);
     expect(node15F?.key).toBe(15);
     expect(node15F?.color).toBe('RED');
-    expect(node15F?.left).toBe(rbTree.SENTINEL);
-    expect(node15F?.right).toBe(rbTree.SENTINEL);
+    expect(node15F?.left).toBe(rbTree.NIL);
+    expect(node15F?.right).toBe(rbTree.NIL);
     expect(node15F?.parent).toBe(node20F);
     expect(node21F?.key).toBe(21);
     expect(node21F?.color).toBe('RED');
-    expect(node21F?.left).toBe(rbTree.SENTINEL);
-    expect(node21F?.right).toBe(rbTree.SENTINEL);
+    expect(node21F?.left).toBe(rbTree.NIL);
+    expect(node21F?.right).toBe(rbTree.NIL);
     expect(node21F?.parent).toBe(node20F);
     expect(node6F?.key).toBe(6);
     expect(node6F?.color).toBe('RED');
-    expect(node6F?.left).toBe(rbTree.SENTINEL);
-    expect(node6F?.right).toBe(rbTree.SENTINEL);
+    expect(node6F?.left).toBe(rbTree.NIL);
+    expect(node6F?.right).toBe(rbTree.NIL);
     expect(node6F?.parent).toBe(node5F);
     expect(node2F?.key).toBe(2);
     expect(node2F?.color).toBe('RED');
-    expect(node2F?.left).toBe(rbTree.SENTINEL);
-    expect(node2F?.right).toBe(rbTree.SENTINEL);
+    expect(node2F?.left).toBe(rbTree.NIL);
+    expect(node2F?.right).toBe(rbTree.NIL);
     expect(node2F?.parent).toBe(node5F);
     expect(node15F?.key).toBe(15);
     expect(node15F?.color).toBe('RED');
-    expect(node15F?.left).toBe(rbTree.SENTINEL);
-    expect(node15F?.right).toBe(rbTree.SENTINEL);
+    expect(node15F?.left).toBe(rbTree.NIL);
+    expect(node15F?.right).toBe(rbTree.NIL);
     expect(node15F?.parent).toBe(node20F);
     rbTree.delete(5);
     node10F = rbTree.getNode(10);
@@ -323,28 +323,28 @@ describe('RedBlackTree 2', () => {
     expect(node5F).toBe(undefined);
     expect(node15F?.key).toBe(15);
     expect(node15F?.color).toBe('RED');
-    expect(node15F?.left).toBe(rbTree.SENTINEL);
-    expect(node15F?.right).toBe(rbTree.SENTINEL);
+    expect(node15F?.left).toBe(rbTree.NIL);
+    expect(node15F?.right).toBe(rbTree.NIL);
     expect(node15F?.parent).toBe(node20F);
     expect(node21F?.key).toBe(21);
     expect(node21F?.color).toBe('RED');
-    expect(node21F?.left).toBe(rbTree.SENTINEL);
-    expect(node21F?.right).toBe(rbTree.SENTINEL);
+    expect(node21F?.left).toBe(rbTree.NIL);
+    expect(node21F?.right).toBe(rbTree.NIL);
     expect(node21F?.parent).toBe(node20F);
     expect(node6F?.key).toBe(6);
     expect(node6F?.color).toBe('BLACK');
     expect(node6F?.left).toBe(node2F);
-    expect(node6F?.right).toBe(rbTree.SENTINEL);
+    expect(node6F?.right).toBe(rbTree.NIL);
     expect(node6F?.parent).toBe(node10F);
     expect(node2F?.key).toBe(2);
     expect(node2F?.color).toBe('RED');
-    expect(node2F?.left).toBe(rbTree.SENTINEL);
-    expect(node2F?.right).toBe(rbTree.SENTINEL);
+    expect(node2F?.left).toBe(rbTree.NIL);
+    expect(node2F?.right).toBe(rbTree.NIL);
     expect(node2F?.parent).toBe(node6F);
     expect(node15F?.key).toBe(15);
     expect(node15F?.color).toBe('RED');
-    expect(node15F?.left).toBe(rbTree.SENTINEL);
-    expect(node15F?.right).toBe(rbTree.SENTINEL);
+    expect(node15F?.left).toBe(rbTree.NIL);
+    expect(node15F?.right).toBe(rbTree.NIL);
     expect(node15F?.parent).toBe(node20F);
     rbTree.delete(20);
     node10F = rbTree.getNode(10);
@@ -363,28 +363,28 @@ describe('RedBlackTree 2', () => {
     expect(node5F).toBe(undefined);
     expect(node15F?.key).toBe(15);
     expect(node15F?.color).toBe('RED');
-    expect(node15F?.left).toBe(rbTree.SENTINEL);
-    expect(node15F?.right).toBe(rbTree.SENTINEL);
+    expect(node15F?.left).toBe(rbTree.NIL);
+    expect(node15F?.right).toBe(rbTree.NIL);
     expect(node15F?.parent).toBe(node21F);
     expect(node21F?.key).toBe(21);
     expect(node21F?.color).toBe('BLACK');
     expect(node21F?.left).toBe(node15F);
-    expect(node21F?.right).toBe(rbTree.SENTINEL);
+    expect(node21F?.right).toBe(rbTree.NIL);
     expect(node21F?.parent).toBe(node10F);
     expect(node6F?.key).toBe(6);
     expect(node6F?.color).toBe('BLACK');
     expect(node6F?.left).toBe(node2F);
-    expect(node6F?.right).toBe(rbTree.SENTINEL);
+    expect(node6F?.right).toBe(rbTree.NIL);
     expect(node6F?.parent).toBe(node10F);
     expect(node2F?.key).toBe(2);
     expect(node2F?.color).toBe('RED');
-    expect(node2F?.left).toBe(rbTree.SENTINEL);
-    expect(node2F?.right).toBe(rbTree.SENTINEL);
+    expect(node2F?.left).toBe(rbTree.NIL);
+    expect(node2F?.right).toBe(rbTree.NIL);
     expect(node2F?.parent).toBe(node6F);
     expect(node15F?.key).toBe(15);
     expect(node15F?.color).toBe('RED');
-    expect(node15F?.left).toBe(rbTree.SENTINEL);
-    expect(node15F?.right).toBe(rbTree.SENTINEL);
+    expect(node15F?.left).toBe(rbTree.NIL);
+    expect(node15F?.right).toBe(rbTree.NIL);
     expect(node15F?.parent).toBe(node21F);
   });
 
@@ -394,8 +394,8 @@ describe('RedBlackTree 2', () => {
     rbTree.add(5);
     rbTree.add(15);
     const node15F = rbTree.getNode(15);
-    expect(node15F?.left).toBe(rbTree.SENTINEL);
-    expect(node15F?.right).toBe(rbTree.SENTINEL);
+    expect(node15F?.left).toBe(rbTree.NIL);
+    expect(node15F?.right).toBe(rbTree.NIL);
     expect(node15F?.parent).toBe(rbTree.getNode(5));
 
     rbTree.add(25);
@@ -410,8 +410,8 @@ describe('RedBlackTree 2', () => {
     rbTree.add(155);
     rbTree.add(225);
     const node225F = rbTree.getNode(225);
-    expect(node225F?.left).toBe(rbTree.SENTINEL);
-    expect(node225F?.right).toBe(rbTree.SENTINEL);
+    expect(node225F?.left).toBe(rbTree.NIL);
+    expect(node225F?.right).toBe(rbTree.NIL);
     expect(node225F?.parent?.key).toBe(155);
     rbTree.add(7);
     isDebug && rbTree.print();
@@ -438,14 +438,14 @@ describe('RedBlackTree 2', () => {
     const node50 = rbTree.getNode(50);
     expect(node50?.key).toBe(50);
     expect(node50?.left?.key).toBe(33);
-    expect(node50?.right).toBe(rbTree.SENTINEL);
+    expect(node50?.right).toBe(rbTree.NIL);
     const node15Fo = rbTree.getNode(15);
 
     expect(node15Fo?.key).toBe(15);
-    expect(node15Fo?.left).toBe(rbTree.SENTINEL);
+    expect(node15Fo?.left).toBe(rbTree.NIL);
     const node225S = rbTree.getNode(225);
-    expect(node225S?.left).toBe(rbTree.SENTINEL);
-    expect(node225S?.right).toBe(rbTree.SENTINEL);
+    expect(node225S?.left).toBe(rbTree.NIL);
+    expect(node225S?.right).toBe(rbTree.NIL);
     expect(node225S?.parent?.key).toBe(155);
     // TODO
     // expect(rbTree.getNode(0)).toBe(undefined);
@@ -512,7 +512,7 @@ describe('RedBlackTree 2', () => {
       rbTree.delete(getRandomInt(-100, 1000));
     }
 
-    // TODO there is a bug when dfs the rbTree with SENTINEL node
+    // TODO there is a bug when dfs the rbTree with NIL node
     // expect(rbTree.isBST()).toBe(true);
   });
   const { HUNDRED_THOUSAND } = magnitude;