data-structure-typed 1.42.3 → 1.42.5

package/src/data-structures/binary-tree/{tree-multiset.ts → tree-multimap.ts}

@@ -5,14 +5,14 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type {BTNKey, TreeMultisetNodeNested, TreeMultisetOptions} from '../../types';
+import type {BTNKey, TreeMultimapNodeNested, TreeMultimapOptions} from '../../types';
 import {BinaryTreeDeletedResult, BTNCallback, CP, FamilyPosition, IterationType} from '../../types';
 import {IBinaryTree} from '../../interfaces';
 import {AVLTree, AVLTreeNode} from './avl-tree';
 
-export class TreeMultisetNode<
+export class TreeMultimapNode<
   V = any,
-  N extends TreeMultisetNode<V, N> = TreeMultisetNodeNested<V>
+  N extends TreeMultimapNode<V, N> = TreeMultimapNodeNested<V>
 > extends AVLTreeNode<V, N> {
   count: number;
 
@@ -33,19 +33,19 @@ export class TreeMultisetNode<
 }
 
 /**
- * The only distinction between a TreeMultiset and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
+ * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
-export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultisetNode<V, TreeMultisetNodeNested<V>>>
+export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultimapNode<V, TreeMultimapNodeNested<V>>>
   extends AVLTree<V, N>
   implements IBinaryTree<V, N>
 {
   /**
-   * The constructor function for a TreeMultiset class in TypeScript, which extends another class and sets an option to
+   * The constructor function for a TreeMultimap class in TypeScript, which extends another class and sets an option to
    * merge duplicated values.
-   * @param {TreeMultisetOptions} [options] - An optional object that contains additional configuration options for the
-   * TreeMultiset.
+   * @param {TreeMultimapOptions} [options] - An optional object that contains additional configuration options for the
+   * TreeMultimap.
    */
-  constructor(options?: TreeMultisetOptions) {
+  constructor(options?: TreeMultimapOptions) {
     super(options);
   }
 
@@ -65,29 +65,30 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
    * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
    */
   override createNode(key: BTNKey, value?: V, count?: number): N {
-    return new TreeMultisetNode(key, value, count) as N;
+    return new TreeMultimapNode(key, value, count) as N;
   }
 
   /**
    * The `add` function adds a new node to a binary search tree, updating the count if the key already
    * exists, and balancing the tree if necessary.
-   * @param {BTNKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a
+   * @param {BTNKey | N | undefined} keyOrNode - The `keyOrNode` parameter can be either a
    * `BTNKey` (which represents the key of the node to be added), a `N` (which represents a
-   * node to be added), or `null` (which represents a null node).
+   * node to be added), or `undefined` (which represents a undefined node).
    * @param [value] - The `value` parameter represents the value associated with the key that is being
    * added to the binary tree.
    * @param [count=1] - The `count` parameter represents the number of occurrences of the key/value
    * pair that will be added to the binary tree. It has a default value of 1, which means that if no
    * count is specified, the default count will be 1.
-   * @returns The function `add` returns a value of type `N | null | undefined`.
+   * @returns The function `add` returns a value of type `N | undefined | undefined`.
    */
-  override add(keyOrNode: BTNKey | N | null, value?: V, count = 1): N | null | undefined {
-    let inserted: N | null | undefined = undefined,
-      newNode: N | null;
-    if (keyOrNode instanceof TreeMultisetNode) {
+  override add(keyOrNode: BTNKey | N | null | undefined, value?: V, count = 1): N | undefined {
+    if(keyOrNode === null) return undefined;
+    let inserted: N  | undefined = undefined,
+      newNode: N | undefined;
+    if (keyOrNode instanceof TreeMultimapNode) {
       newNode = this.createNode(keyOrNode.key, keyOrNode.value, keyOrNode.count);
-    } else if (keyOrNode === null) {
-      newNode = null;
+    } else if (keyOrNode === undefined) {
+      newNode = undefined;
     } else {
       newNode = this.createNode(keyOrNode, value, count);
     }
@@ -138,7 +139,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
               }
             }
           } else {
-            // TODO may need to support null inserted
+            // TODO may need to support undefined inserted
           }
         } else {
           traversing = false;
@@ -151,17 +152,17 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
 
   /**
    * The function adds a new node to a binary tree if there is an available slot in the parent node.
-   * @param {N | null} newNode - The `newNode` parameter represents the node that needs to be added to
-   * the tree. It can be either a node object (`N`) or `null`.
+   * @param {N | undefined} newNode - The `newNode` parameter represents the node that needs to be added to
+   * the tree. It can be either a node object (`N`) or `undefined`.
    * @param {N} parent - The `parent` parameter represents the parent node to which the new node will
    * be added as a child.
    * @returns The method `_addTo` returns either the `parent.left`, `parent.right`, or `undefined`.
    */
-  override _addTo(newNode: N | null, parent: N): N | null | undefined {
+  override _addTo(newNode: N | undefined, parent: N): N | undefined {
     if (parent) {
       if (parent.left === undefined) {
         parent.left = newNode;
-        if (newNode !== null) {
+        if (newNode !== undefined) {
           this._size = this.size + 1;
           this._setCount(this.count + newNode.count);
         }
@@ -169,7 +170,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
         return parent.left;
       } else if (parent.right === undefined) {
         parent.right = newNode;
-        if (newNode !== null) {
+        if (newNode !== undefined) {
           this._size = this.size + 1;
           this._setCount(this.count + newNode.count);
         }
@@ -183,27 +184,27 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
   }
 
   /**
-   * The `addMany` function adds multiple keys or nodes to a TreeMultiset and returns an array of the
+   * The `addMany` function adds multiple keys or nodes to a TreeMultimap and returns an array of the
    * inserted nodes.
-   * @param {(BTNKey | null)[] | (N | null)[]} keysOrNodes - An array of keys or nodes to be
-   * added to the multiset. Each element can be either a BTNKey or a TreeMultisetNode.
+   * @param {(BTNKey | undefined)[] | (N | undefined)[]} keysOrNodes - An array of keys or nodes to be
+   * added to the multiset. Each element can be either a BTNKey or a TreeMultimapNode.
    * @param {V[]} [data] - The `data` parameter is an optional array of values that correspond
    * to the keys or nodes being added to the multiset. It is used to associate additional data with
    * each key or node.
-   * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
+   * @returns The function `addMany` returns an array of `N`, `undefined`, or `undefined` values.
    */
-  override addMany(keysOrNodes: (BTNKey | null)[] | (N | null)[], data?: V[]): (N | null | undefined)[] {
-    const inserted: (N | null | undefined)[] = [];
+  override addMany(keysOrNodes: (BTNKey | undefined)[] | (N | undefined)[], data?: V[]): (N | undefined)[] {
+    const inserted: (N | undefined | undefined)[] = [];
 
     for (let i = 0; i < keysOrNodes.length; i++) {
       const keyOrNode = keysOrNodes[i];
 
-      if (keyOrNode instanceof TreeMultisetNode) {
+      if (keyOrNode instanceof TreeMultimapNode) {
         inserted.push(this.add(keyOrNode.key, keyOrNode.value, keyOrNode.count));
         continue;
       }
 
-      if (keyOrNode === null) {
+      if (keyOrNode === undefined) {
         inserted.push(this.add(NaN, undefined, 0));
         continue;
       }
@@ -283,11 +284,11 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
     const bstDeletedResult: BinaryTreeDeletedResult<N>[] = [];
     if (!this.root) return bstDeletedResult;
 
-    const curr: N | null = this.getNode(identifier, callback);
+    const curr: N | undefined = this.getNode(identifier, callback) ?? undefined;
     if (!curr) return bstDeletedResult;
 
-    const parent: N | null = curr?.parent ? curr.parent : null;
-    let needBalanced: N | null = null,
+    const parent: N | undefined = curr?.parent ? curr.parent : undefined;
+    let needBalanced: N | undefined = undefined,
       orgCurrent = curr;
 
     if (curr.count > 1 && !ignoreCount) {
@@ -307,7 +308,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
           needBalanced = parent;
         }
       } else {
-        const leftSubTreeRightMost = curr.left ? this.getRightMost(curr.left) : null;
+        const leftSubTreeRightMost = curr.left ? this.getRightMost(curr.left) : undefined;
         if (leftSubTreeRightMost) {
           const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
           orgCurrent = this._swap(curr, leftSubTreeRightMost);

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

@@ -24,7 +24,7 @@ export enum FamilyPosition {
 
 export type BTNKey = number;
 
-export type BinaryTreeDeletedResult<N> = { deleted: N | null | undefined; needBalanced: N | null };
+export type BinaryTreeDeletedResult<N> = { deleted: N | null | undefined; needBalanced: N | null | undefined };
 
 export type BinaryTreeNodeNested<T> = BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 

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

@@ -2,5 +2,5 @@ export * from './binary-tree';
 export * from './bst';
 export * from './avl-tree';
 export * from './segment-tree';
-export * from './tree-multiset';
+export * from './tree-multimap';
 export * from './rb-tree';

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

@@ -1,8 +1,8 @@
-// import {BinaryTreeOptions} from './binary-tree';
-// import {RBTreeNode} from '../../../data-structures';
+import {RBTreeNode} from '../../../data-structures';
+import {BSTOptions} from "./bst";
 
 export enum RBTNColor { RED = 1, BLACK = 0}
 
-// export type RBTreeNodeNested<T> = RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
-//
-// export type RBTreeOptions = BinaryTreeOptions & {}
+export type RBTreeNodeNested<T> = RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+export type RBTreeOptions = BSTOptions & {};

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

@@ -0,0 +1,6 @@
+import {TreeMultimapNode} from '../../../data-structures';
+import {AVLTreeOptions} from './avl-tree';
+
+export type TreeMultimapNodeNested<T> = TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+export type TreeMultimapOptions = Omit<AVLTreeOptions, 'isMergeDuplicatedNodeByKey'> & {}

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

@@ -14,12 +14,12 @@ suite
       rbTree.add(arr[i]);
     }
   })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & 1000 delete randomly`, () => {
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & delete randomly`, () => {
     rbTree.clear();
     for (let i = 0; i < arr.length; i++) {
       rbTree.add(arr[i]);
     }
-    for (let i = 0; i < 1000; i++) {
+    for (let i = 0; i < arr.length; i++) {
       rbTree.delete(arr[i]);
     }
   })

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

@@ -36,7 +36,6 @@ describe('AVL Tree Test', () => {
     const dfs = tree.dfs(node => node, 'in');
     expect(dfs[0].key).toBe(1);
     expect(dfs[dfs.length - 1].key).toBe(16);
-
     tree.perfectlyBalance();
     const bfs = tree.bfs(node => node);
     expect(tree.isPerfectlyBalanced()).toBe(true);
@@ -266,4 +265,24 @@ describe('AVLTree', () => {
 
     // You can add more specific assertions to check the tree's balance and structure.
   });
+
+  describe('BinaryTree APIs test', () => {
+    const avl = new AVLTree<{id: number; text: string}>();
+    beforeEach(() => {
+      avl.clear();
+    });
+
+    it('add', () => {
+      avl.add(1);
+      const node2 = new AVLTreeNode(2);
+      avl.add(node2);
+      const node3 = new AVLTreeNode(3, {id: 3, text: 'text3'});
+      avl.add(node3);
+      avl.add(node3, {id: 3, text: 'text33'});
+
+      const bfsRes = avl.bfs(node => node);
+      expect(bfsRes[0]?.key).toBe(2);
+    });
+  });
+
 });

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

@@ -1,4 +1,4 @@
-import {AVLTree, AVLTreeNode, BinaryTree, BinaryTreeNode, IterationType} from '../../../../src';
+import {BinaryTree, BinaryTreeNode, IterationType} from '../../../../src';
 // import {isDebugTest} from '../../../config';
 
 // const isDebug = isDebugTest;
@@ -177,10 +177,10 @@ describe('BinaryTree', () => {
     expect(tree.subTreeTraverse(node => node.key, tree.getNode(6), IterationType.ITERATIVE)).toEqual([6, 3, 7]);
     expect(tree.subTreeTraverse(node => node.key, tree.getNode(6), IterationType.RECURSIVE)).toEqual([6, 3, 7]);
     expect(
-      tree.subTreeTraverse(node => (node === null ? null : node.key), tree.getNode(6), IterationType.ITERATIVE, true)
+      tree.subTreeTraverse(node => (node ? node.key : null ), tree.getNode(6), IterationType.ITERATIVE, true)
     ).toEqual([6, 3, 7, null]);
     expect(
-      tree.subTreeTraverse(node => (node === null ? null : node.key), tree.getNode(6), IterationType.RECURSIVE, true)
+      tree.subTreeTraverse(node => (node ? node.key : null ), tree.getNode(6), IterationType.RECURSIVE, true)
     ).toEqual([6, 3, 7, null]);
   });
 
@@ -193,7 +193,7 @@ describe('BinaryTree', () => {
     tree.clear();
 
     expect(tree.size).toBe(0);
-    expect(tree.root).toBeNull();
+    expect(tree.root).toBeUndefined();
   });
 });
 
@@ -248,35 +248,16 @@ describe('BinaryTree Morris Traversal', () => {
   });
 });
 
-describe('BinaryTree APIs test', () => {
-  const avl = new AVLTree<{id: number; text: string}>();
-  beforeEach(() => {
-    avl.clear();
-  });
-
-  it('add', () => {
-    avl.add(1);
-    const node2 = new AVLTreeNode(2);
-    avl.add(node2);
-    const node3 = new AVLTreeNode(3, {id: 3, text: 'text3'});
-    avl.add(node3);
-    avl.add(node3, {id: 3, text: 'text33'});
-
-    const bfsRes = avl.bfs(node => node);
-    expect(bfsRes[0]?.key).toBe(2);
-  });
-});
-
 describe('BinaryTree traversals', () => {
   const tree = new BinaryTree<number>();
 
   const arr = [35, 20, 40, 15, 29, null, 50, null, 16, 28, 30, 45, 55];
   tree.refill(arr);
   expect(
-    tree.bfs(node => node, tree.root, IterationType.ITERATIVE, true).map(node => (node === null ? null : node.key))
+    tree.bfs(node => node, tree.root, IterationType.ITERATIVE, true).map(node => (node ? node.key : null ))
   ).toEqual([35, 20, 40, 15, 29, null, 50, null, 16, 28, 30, 45, 55]);
   expect(
-    tree.bfs(node => node, tree.root, IterationType.RECURSIVE, true).map(node => (node === null ? null : node.key))
+    tree.bfs(node => node, tree.root, IterationType.RECURSIVE, true).map(node => (node ? node.key : null ))
   ).toEqual([35, 20, 40, 15, 29, null, 50, null, 16, 28, 30, 45, 55]);
   expect(
     tree.bfs(node => node, tree.root, IterationType.ITERATIVE).map(node => (node === null ? null : node.key))
@@ -292,12 +273,12 @@ describe('BinaryTree traversals', () => {
   expect(
     tree
       .dfs(node => node, 'pre', tree.root, IterationType.ITERATIVE, true)
-      .map(node => (node === null ? null : node.key))
+      .map(node => (node ? node.key : null ))
   ).toEqual([35, 20, 15, null, 16, 29, 28, 30, 40, null, 50, 45, 55]);
   expect(
     tree
       .dfs(node => node, 'pre', tree.root, IterationType.RECURSIVE, true)
-      .map(node => (node === null ? null : node.key))
+      .map(node => (node ? node.key : null ))
   ).toEqual([35, 20, 15, null, 16, 29, 28, 30, 40, null, 50, 45, 55]);
 
   expect(tree.dfs(node => node.key, 'in')).toEqual([15, 16, 20, 28, 29, 30, 35, 40, 45, 50, 55]);
@@ -320,13 +301,13 @@ describe('BinaryTree traversals', () => {
     [15, 29, 50],
     [16, 28, 30, 45, 55]
   ]);
-  expect(tree.listLevels(node => (node === null ? null : node.key), tree.root, IterationType.ITERATIVE, true)).toEqual([
+  expect(tree.listLevels(node => (node ? node.key : null ), tree.root, IterationType.ITERATIVE, true)).toEqual([
     [35],
     [20, 40],
     [15, 29, null, 50],
     [null, 16, 28, 30, 45, 55]
   ]);
-  expect(tree.listLevels(node => (node === null ? null : node.key), tree.root, IterationType.RECURSIVE, true)).toEqual([
+  expect(tree.listLevels(node => ( node ? node.key : null ), tree.root, IterationType.RECURSIVE, true)).toEqual([
     [35],
     [20, 40],
     [15, 29, null, 50],
@@ -348,7 +329,7 @@ describe('BinaryTree', () => {
   it('should create an empty BinaryTree', () => {
     expect(tree.size).toBe(0);
     expect(tree.isEmpty()).toBe(true);
-    expect(tree.root).toBe(null);
+    expect(tree.root).toBe(undefined);
   });
 
   it('should add nodes to the tree', () => {
@@ -370,7 +351,7 @@ describe('BinaryTree', () => {
 
     expect(tree.size).toBe(0);
     expect(tree.isEmpty()).toBe(true);
-    expect(tree.root).toBe(null);
+    expect(tree.root).toBe(undefined);
   });
 
   it('should get nodes by key', () => {

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

@@ -840,14 +840,14 @@ describe('BST Performance test', function () {
 
   it('should subTreeTraverse, null should be ignored', () => {
     const bst = new BST();
-    bst.addMany([4, 2, 6, null, 1, 3, null, 5, null, 7]);
+    bst.addMany([4, 2, 6, 1, 3, 5, 7]);
     expect(bst.subTreeTraverse(node => node.key, bst.getNode(6), IterationType.ITERATIVE)).toEqual([6, 5, 7]);
     expect(bst.subTreeTraverse(node => node.key, bst.getNode(6), IterationType.RECURSIVE)).toEqual([6, 5, 7]);
     expect(
-      bst.subTreeTraverse(node => (node === null ? null : node.key), bst.getNode(6), IterationType.ITERATIVE, true)
+      bst.subTreeTraverse(node => (node?.key ?? undefined), bst.getNode(6), IterationType.ITERATIVE, true)
     ).toEqual([6, 5, 7]);
     expect(
-      bst.subTreeTraverse(node => (node === null ? null : node.key), bst.getNode(6), IterationType.RECURSIVE, true)
+      bst.subTreeTraverse(node => (node?.key ?? undefined), bst.getNode(6), IterationType.RECURSIVE, true)
     ).toEqual([6, 5, 7]);
   });
 });