data-structure-typed 1.42.2 → 1.42.4

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

@@ -71,23 +71,24 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
   /**
    * 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;
+  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 TreeMultisetNode) {
       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);
         }
@@ -185,15 +186,15 @@ 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
    * inserted nodes.
-   * @param {(BTNKey | null)[] | (N | null)[]} keysOrNodes - An array of keys or nodes to be
+   * @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 TreeMultisetNode.
    * @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];
@@ -203,7 +204,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
         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/data-structures/graph/abstract-graph.ts

@@ -64,7 +64,8 @@ export abstract class AbstractGraph<
   E = any,
   VO extends AbstractVertex<V> = AbstractVertex<V>,
   EO extends AbstractEdge<E> = AbstractEdge<E>
-> implements IGraph<V, E, VO, EO> {
+> implements IGraph<V, E, VO, EO>
+{
   protected _vertices: Map<VertexKey, VO> = new Map<VertexKey, VO>();
 
   get vertices(): Map<VertexKey, VO> {
@@ -234,7 +235,7 @@ export abstract class AbstractGraph<
       return [];
     }
 
-    const stack: { vertex: VO, path: VO[] }[] = [];
+    const stack: {vertex: VO; path: VO[]}[] = [];
     stack.push({vertex: vertex1, path: [vertex1]});
 
     while (stack.length > 0) {
@@ -256,7 +257,6 @@ export abstract class AbstractGraph<
     return paths;
   }
 
-
   /**
    * The function calculates the sum of weights along a given path.
    * @param {VO[]} path - An array of vertices (VO) representing a path in a graph.
@@ -366,7 +366,6 @@ export abstract class AbstractGraph<
       } else {
         return this.dijkstra(v1, v2, true, true)?.minPath ?? [];
       }
-
     } else {
       // DFS
       let minPath: VO[] = [];
@@ -519,14 +518,14 @@ export abstract class AbstractGraph<
     }
 
     getMinDist &&
-    distMap.forEach((d, v) => {
-      if (v !== srcVertex) {
-        if (d < minDist) {
-          minDist = d;
-          if (genPaths) minDest = v;
+      distMap.forEach((d, v) => {
+        if (v !== srcVertex) {
+          if (d < minDist) {
+            minDist = d;
+            if (genPaths) minDest = v;
+          }
         }
-      }
-    });
+      });
 
     genPaths && getPaths(minDest);
 
@@ -588,7 +587,7 @@ export abstract class AbstractGraph<
       if (vertexOrKey instanceof AbstractVertex) distMap.set(vertexOrKey, Infinity);
     }
 
-    const heap = new PriorityQueue<{ key: number; value: VO }>({comparator: (a, b) => a.key - b.key});
+    const heap = new PriorityQueue<{key: number; value: VO}>({comparator: (a, b) => a.key - b.key});
     heap.add({key: 0, value: srcVertex});
 
     distMap.set(srcVertex, 0);
@@ -812,7 +811,7 @@ export abstract class AbstractGraph<
    * `predecessor` property is a 2D array of vertices (or `null`) representing the predecessor vertices in the shortest
    * path between vertices in the
    */
-  floydWarshall(): { costs: number[][]; predecessor: (VO | null)[][] } {
+  floydWarshall(): {costs: number[][]; predecessor: (VO | null)[][]} {
     const idAndVertices = [...this._vertices];
     const n = idAndVertices.length;
 
@@ -876,7 +875,12 @@ export abstract class AbstractGraph<
    * are arrays of vertices that form cycles within the SCCs.
    * @returns The function `tarjan` returns an object with the following properties:
    */
-  tarjan(needCutVertexes: boolean = false, needBridges: boolean = false, needSCCs: boolean = true, needCycles: boolean = false) {
+  tarjan(
+    needCutVertexes: boolean = false,
+    needBridges: boolean = false,
+    needSCCs: boolean = true,
+    needCycles: boolean = false
+  ) {
     // !! in undirected graph we will not let child visit parent when dfs
     // !! articulation point(in dfs search tree not in graph): (cur !== root && cur.has(child)) && (low(child) >= dfn(cur)) || (cur === root && cur.children() >= 2)
     // !! bridge: low(child) > dfn(cur)

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/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/test/performance/reportor.ts

@@ -107,6 +107,7 @@ const composeReport = () => {
   fs.writeFileSync(htmlFilePath, html);
   console.log(`Performance ${BOLD}${GREEN}report${END} file generated`);
 };
+
 function replaceMarkdownContent(startMarker: string, endMarker: string, newText: string) {
   const parentDirectory = path.resolve(__dirname, '../..'); // The path to the parent directory
   const filePath = path.join(parentDirectory, 'README.md'); // Path to README.md file

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;
@@ -174,10 +174,14 @@ describe('BinaryTree', () => {
 
   it('should subTreeTraverse', () => {
     tree.addMany([4, 2, 6, null, 1, 3, null, 5, null, 7]);
-    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)).toEqual([6, 3, 7, null]);
-    expect(tree.subTreeTraverse(node => node === null? null : node.key, tree.getNode(6), IterationType.RECURSIVE, true)).toEqual([6, 3, 7, null]);
+    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 ? node.key : null ), tree.getNode(6), IterationType.ITERATIVE, true)
+    ).toEqual([6, 3, 7, null]);
+    expect(
+      tree.subTreeTraverse(node => (node ? node.key : null ), tree.getNode(6), IterationType.RECURSIVE, true)
+    ).toEqual([6, 3, 7, null]);
   });
 
   it('should clear the tree', () => {
@@ -189,7 +193,7 @@ describe('BinaryTree', () => {
     tree.clear();
 
     expect(tree.size).toBe(0);
-    expect(tree.root).toBeNull();
+    expect(tree.root).toBeUndefined();
   });
 });
 
@@ -244,41 +248,38 @@ 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)).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)).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)).toEqual([35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55]);
-  expect(tree.bfs(node => node , tree.root, IterationType.RECURSIVE).map(node => node === null ? null : node.key)).toEqual([35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55]);
+  expect(
+    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 ? 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))
+  ).toEqual([35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55]);
+  expect(
+    tree.bfs(node => node, tree.root, IterationType.RECURSIVE).map(node => (node === null ? null : node.key))
+  ).toEqual([35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55]);
 
   expect(tree.dfs(node => node.key, 'pre')).toEqual([35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55]);
   expect(tree.dfs(node => node.key, 'pre', tree.root, IterationType.RECURSIVE)).toEqual([
     35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55
   ]);
-  expect(tree.dfs(node => node, 'pre', tree.root, IterationType.ITERATIVE, true).map(node => node === null ? null : node.key)).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)).toEqual([35, 20, 15, null, 16, 29, 28, 30, 40, null, 50, 45, 55]);
+  expect(
+    tree
+      .dfs(node => node, 'pre', tree.root, IterationType.ITERATIVE, true)
+      .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 ? 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]);
   expect(tree.dfs(node => node.key, 'post')).toEqual([16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35]);
@@ -300,21 +301,20 @@ 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],
+    [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],
+    [15, 29, null, 50],
     [null, 16, 28, 30, 45, 55]
   ]);
 });
 
-
 describe('BinaryTree', () => {
   let tree: BinaryTree<string>;
 
@@ -329,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', () => {
@@ -351,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

@@ -837,4 +837,17 @@ describe('BST Performance test', function () {
     bst.addMany([9, 8, 7, 3, 1, 2, 5, 4, 6], undefined, false);
     expect(bst.lastKey()).toBe(9);
   });
+
+  it('should subTreeTraverse, null should be ignored', () => {
+    const bst = new BST();
+    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?.key ?? undefined), bst.getNode(6), IterationType.ITERATIVE, true)
+    ).toEqual([6, 5, 7]);
+    expect(
+      bst.subTreeTraverse(node => (node?.key ?? undefined), bst.getNode(6), IterationType.RECURSIVE, true)
+    ).toEqual([6, 5, 7]);
+  });
 });