data-structure-typed 1.51.0 → 1.51.2

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';
@@ -214,15 +214,15 @@ export class BST<
     keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>,
     iterationType: IterationType = 'ITERATIVE'
   ): NODE | undefined {
-    let res: NODE | undefined;
     if (this.isRealNode(keyOrNodeOrEntry)) {
-      res = keyOrNodeOrEntry;
+      return keyOrNodeOrEntry;
     } else if (this.isEntry(keyOrNodeOrEntry)) {
-      if (keyOrNodeOrEntry[0]) res = this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
+      if (keyOrNodeOrEntry[0] === null || keyOrNodeOrEntry[0] === undefined) return;
+      return this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
     } else {
-      if (keyOrNodeOrEntry) res = this.getNodeByKey(keyOrNodeOrEntry, iterationType);
+      if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === undefined) return;
+      return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
     }
-    return res;
   }
 
   /**
@@ -426,26 +426,26 @@ export class BST<
    * found in the binary tree. If no node is found, it returns `undefined`.
    */
   override getNodeByKey(key: K, iterationType: IterationType = 'ITERATIVE'): NODE | undefined {
-    // return this.getNodes(key, this._defaultOneParamCallback, true, this.root, iterationType)[0];
-    if (!this.isRealNode(this.root)) return undefined;
+    // return this.getNodes(key, this._DEFAULT_CALLBACK, true, this.root, iterationType)[0];
+    if (!this.isRealNode(this.root)) return;
     if (iterationType === 'RECURSIVE') {
-      const _dfs = (cur: NODE): NODE | undefined => {
+      const dfs = (cur: NODE): NODE | undefined => {
         if (cur.key === key) return cur;
         if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
 
-        if (this._compare(cur.key, key) === 'GT' && this.isRealNode(cur.left)) return _dfs(cur.left);
-        if (this._compare(cur.key, key) === 'LT' && this.isRealNode(cur.right)) return _dfs(cur.right);
+        if (this.isRealNode(cur.left) && this._compare(cur.key, key) === 'GT') return dfs(cur.left);
+        if (this.isRealNode(cur.right) && this._compare(cur.key, key) === 'LT') return dfs(cur.right);
       };
 
-      return _dfs(this.root);
+      return dfs(this.root);
     } else {
-      const queue = new Queue<NODE>([this.root]);
-      while (queue.size > 0) {
-        const cur = queue.shift();
+      const stack = [this.root];
+      while (stack.length > 0) {
+        const cur = stack.pop();
         if (this.isRealNode(cur)) {
           if (this._compare(cur.key, key) === 'EQ') return cur;
-          if (this._compare(cur.key, key) === 'GT') this.isRealNode(cur.left) && queue.push(cur.left);
-          if (this._compare(cur.key, key) === 'LT') this.isRealNode(cur.right) && queue.push(cur.right);
+          if (this.isRealNode(cur.left) && this._compare(cur.key, key) === 'GT') stack.push(cur.left);
+          if (this.isRealNode(cur.right) && this._compare(cur.key, key) === 'LT') stack.push(cur.right);
         }
       }
     }
@@ -481,7 +481,7 @@ export class BST<
    */
   override getNodes<C extends BTNCallback<NODE>>(
     identifier: ReturnType<C> | undefined,
-    callback: C = this._defaultOneParamCallback as C,
+    callback: C = this._DEFAULT_CALLBACK as C,
     onlyOne = false,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
@@ -491,7 +491,7 @@ export class BST<
     const ans: NODE[] = [];
 
     if (iterationType === 'RECURSIVE') {
-      const _traverse = (cur: NODE) => {
+      const dfs = (cur: NODE) => {
         const callbackResult = callback(cur);
         if (callbackResult === identifier) {
           ans.push(cur);
@@ -500,16 +500,16 @@ export class BST<
 
         if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
         // TODO potential bug
-        if (callback === this._defaultOneParamCallback) {
-          if (this.isRealNode(cur.left) && this._compare(cur.key, identifier as K) === 'GT') _traverse(cur.left);
-          if (this.isRealNode(cur.right) && this._compare(cur.key, identifier as K) === 'LT') _traverse(cur.right);
+        if (callback === this._DEFAULT_CALLBACK) {
+          if (this.isRealNode(cur.left) && this._compare(cur.key, identifier as K) === 'GT') dfs(cur.left);
+          if (this.isRealNode(cur.right) && this._compare(cur.key, identifier as K) === 'LT') dfs(cur.right);
         } else {
-          this.isRealNode(cur.left) && _traverse(cur.left);
-          this.isRealNode(cur.right) && _traverse(cur.right);
+          this.isRealNode(cur.left) && dfs(cur.left);
+          this.isRealNode(cur.right) && dfs(cur.right);
         }
       };
 
-      _traverse(beginRoot);
+      dfs(beginRoot);
     } else {
       const stack = [beginRoot];
       while (stack.length > 0) {
@@ -521,7 +521,7 @@ export class BST<
             if (onlyOne) return ans;
           }
           // TODO potential bug
-          if (callback === this._defaultOneParamCallback) {
+          if (callback === this._DEFAULT_CALLBACK) {
             if (this.isRealNode(cur.right) && this._compare(cur.key, identifier as K) === 'LT') stack.push(cur.right);
             if (this.isRealNode(cur.left) && this._compare(cur.key, identifier as K) === 'GT') stack.push(cur.left);
 
@@ -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)
@@ -568,7 +603,7 @@ export class BST<
    * @returns The method is returning an array of the return type of the callback function.
    */
   override dfs<C extends BTNCallback<NODE>>(
-    callback: C = this._defaultOneParamCallback as C,
+    callback: C = this._DEFAULT_CALLBACK as C,
     pattern: DFSOrderPattern = 'IN',
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = 'ITERATIVE'
@@ -599,7 +634,7 @@ export class BST<
    * @returns The method is returning an array of the return type of the callback function.
    */
   override bfs<C extends BTNCallback<NODE>>(
-    callback: C = this._defaultOneParamCallback as C,
+    callback: C = this._DEFAULT_CALLBACK as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): ReturnType<C>[] {
@@ -630,7 +665,7 @@ export class BST<
    * function.
    */
   override listLevels<C extends BTNCallback<NODE>>(
-    callback: C = this._defaultOneParamCallback as C,
+    callback: C = this._DEFAULT_CALLBACK as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): ReturnType<C>[][] {
@@ -700,7 +735,7 @@ export class BST<
    * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
    */
   lesserOrGreaterTraverse<C extends BTNCallback<NODE>>(
-    callback: C = this._defaultOneParamCallback as C,
+    callback: C = this._DEFAULT_CALLBACK as C,
     lesserOrGreater: CP = 'LT',
     targetNode: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
@@ -713,15 +748,15 @@ export class BST<
     const targetKey = targetNode.key;
 
     if (iterationType === 'RECURSIVE') {
-      const _traverse = (cur: NODE) => {
+      const dfs = (cur: NODE) => {
         const compared = this._compare(cur.key, targetKey);
         if (compared === lesserOrGreater) ans.push(callback(cur));
 
-        if (this.isRealNode(cur.left)) _traverse(cur.left);
-        if (this.isRealNode(cur.right)) _traverse(cur.right);
+        if (this.isRealNode(cur.left)) dfs(cur.left);
+        if (this.isRealNode(cur.right)) dfs(cur.right);
       };
 
-      _traverse(this.root);
+      dfs(this.root);
       return ans;
     } else {
       const queue = new Queue<NODE>([this.root]);

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._defaultOneParamCallback 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;
   }
 
   /**
@@ -308,13 +242,13 @@ export class RedBlackTree<
    * deleted is not found.
    * @param {C} callback - The `callback` parameter is a function that is used to retrieve a node from
    * the binary tree based on its identifier. It is an optional parameter and if not provided, the
-   * `_defaultOneParamCallback` function is used as the default callback. The callback function should
+   * `_DEFAULT_CALLBACK` function is used as the default callback. The callback function should
    * return the identifier of the node to
    * @returns an array of BinaryTreeDeleteResult<NODE> objects.
    */
   override delete<C extends BTNCallback<NODE>>(
     identifier: ReturnType<C> | null | undefined,
-    callback: C = this._defaultOneParamCallback as C
+    callback: C = this._DEFAULT_CALLBACK as C
   ): BinaryTreeDeleteResult<NODE>[] {
     if (identifier === null) return [];
     const results: BinaryTreeDeleteResult<NODE>[] = [];
@@ -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/src/data-structures/binary-tree/tree-multi-map.ts

@@ -242,7 +242,7 @@ export class TreeMultiMap<
    * function. It can also be null or undefined if no node needs to be deleted.
    * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` as
    * input and returns a value of type `ReturnType<C>`. It is used to determine if a node matches the
-   * identifier for deletion. If no callback is provided, the `_defaultOneParamCallback` function is
+   * identifier for deletion. If no callback is provided, the `_DEFAULT_CALLBACK` function is
    * used
    * @param [ignoreCount=false] - A boolean value indicating whether to ignore the count of the target
    * node when performing deletion. If set to true, the count of the target node will not be considered
@@ -252,7 +252,7 @@ export class TreeMultiMap<
    */
   override delete<C extends BTNCallback<NODE>>(
     identifier: ReturnType<C> | null | undefined,
-    callback: C = this._defaultOneParamCallback as C,
+    callback: C = this._DEFAULT_CALLBACK as C,
     ignoreCount = false
   ): BinaryTreeDeleteResult<NODE>[] {
     if (identifier === null) return [];

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;

package/test/unit/data-structures/binary-tree/tree-multi-map.test.ts

@@ -45,6 +45,7 @@ describe('TreeMultiMap operations test1', () => {
     expect(tmm.getMinHeight()).toBe(-1);
 
     tmm.addMany([1, 6, 7, 2, 3, 4, 9, 11, 8, 5, 10, 12, 16, 14, 13, 15]);
+    // tmm.print()
     expect(tmm.getHeight()).toBe(5);
     expect(tmm.getMinHeight()).toBe(2);
   });

package/test/utils/big-o.ts

@@ -205,3 +205,15 @@ export function logBigOMetrics(target: any, propertyKey: string, descriptor: Pro
 
   return descriptor;
 }
+
+export const logPerf = function (fn: (...args: any[]) => any, args: any[], thisArg?: any) {
+  const start = performance.now();
+  if (thisArg) {
+    if (args && args.length > 0) fn.apply(thisArg, args);
+    else fn.apply(thisArg);
+  } else {
+    if (args && args.length > 0) fn(...args);
+    else fn();
+  }
+  console.log(`function running cost : ${(performance.now() - start).toFixed(2)} ms`);
+};