data-structure-typed 1.52.6 → 1.52.7

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

@@ -75,13 +75,13 @@ describe('AVLTreeMultiMap operations test1', () => {
     const nodeId10 = treeMultimap.getNode(10);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = treeMultimap.getNode(9, node => node.value);
+    const nodeVal9 = treeMultimap.getNode(node => node.value === 9);
     expect(nodeVal9?.key).toBe(9);
 
-    const nodesByCount1 = treeMultimap.getNodes(1, node => node.count);
+    const nodesByCount1 = treeMultimap.getNodes(node => node.count === 1);
     expect(nodesByCount1.length).toBe(14);
 
-    const nodesByCount2 = treeMultimap.getNodes(2, node => node.count);
+    const nodesByCount2 = treeMultimap.getNodes(node => node.count === 2);
     expect(nodesByCount2.length).toBe(2);
     const leftMost = treeMultimap.getLeftMost();
     expect(leftMost).toBe(1);
@@ -91,7 +91,7 @@ describe('AVLTreeMultiMap operations test1', () => {
     expect(minNodeBySpecificNode?.key).toBe(15);
 
     let subTreeSum = 0;
-    node15 && treeMultimap.dfs(node => (subTreeSum += node.key), 'PRE', 15);
+    if (node15) treeMultimap.dfs(node => (subTreeSum += node.key), 'PRE', 15);
     expect(subTreeSum).toBe(31);
     let lesserSum = 0;
     treeMultimap.lesserOrGreaterTraverse((node: AVLTreeMultiMapNode<number>) => (lesserSum += node.key), -1, 10);
@@ -123,7 +123,7 @@ describe('AVLTreeMultiMap operations test1', () => {
     expect(bfsNodesAfterBalanced[0].key).toBe(8);
     expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
 
-    const removed11 = treeMultimap.delete(11, undefined, true);
+    const removed11 = treeMultimap.delete(11, true);
     expect(removed11 instanceof Array);
     expect(removed11[0]);
     expect(removed11[0].deleted);
@@ -134,7 +134,7 @@ describe('AVLTreeMultiMap operations test1', () => {
 
     expect(treeMultimap.getHeight(15)).toBe(1);
 
-    const removed1 = treeMultimap.delete(1, undefined, true);
+    const removed1 = treeMultimap.delete(1, true);
     expect(removed1 instanceof Array);
     expect(removed1[0]);
     expect(removed1[0].deleted);
@@ -144,7 +144,7 @@ describe('AVLTreeMultiMap operations test1', () => {
 
     expect(treeMultimap.getHeight()).toBe(4);
 
-    const removed4 = treeMultimap.delete(4, undefined, true);
+    const removed4 = treeMultimap.delete(4, true);
     expect(removed4 instanceof Array);
     expect(removed4[0]);
     expect(removed4[0].deleted);
@@ -153,7 +153,7 @@ describe('AVLTreeMultiMap operations test1', () => {
     expect(treeMultimap.isAVLBalanced()).toBe(true);
     expect(treeMultimap.getHeight()).toBe(4);
 
-    const removed10 = treeMultimap.delete(10, undefined, true);
+    const removed10 = treeMultimap.delete(10, true);
     expect(removed10 instanceof Array);
     expect(removed10[0]);
     expect(removed10[0].deleted);
@@ -162,7 +162,7 @@ describe('AVLTreeMultiMap operations test1', () => {
 
     expect(treeMultimap.getHeight()).toBe(3);
 
-    const removed15 = treeMultimap.delete(15, undefined, true);
+    const removed15 = treeMultimap.delete(15, true);
     expect(removed15 instanceof Array);
     expect(removed15[0]);
     expect(removed15[0].deleted);
@@ -171,7 +171,7 @@ describe('AVLTreeMultiMap operations test1', () => {
     expect(treeMultimap.isAVLBalanced()).toBe(true);
     expect(treeMultimap.getHeight()).toBe(3);
 
-    const removed5 = treeMultimap.delete(5, undefined, true);
+    const removed5 = treeMultimap.delete(5, true);
     expect(removed5 instanceof Array);
     expect(removed5[0]);
     expect(removed5[0].deleted);
@@ -180,7 +180,7 @@ describe('AVLTreeMultiMap operations test1', () => {
     expect(treeMultimap.isAVLBalanced()).toBe(true);
     expect(treeMultimap.getHeight()).toBe(3);
 
-    const removed13 = treeMultimap.delete(13, undefined, true);
+    const removed13 = treeMultimap.delete(13, true);
     expect(removed13 instanceof Array);
     expect(removed13[0]);
     expect(removed13[0].deleted);
@@ -188,7 +188,7 @@ describe('AVLTreeMultiMap operations test1', () => {
     expect(treeMultimap.isAVLBalanced()).toBe(true);
     expect(treeMultimap.getHeight()).toBe(3);
 
-    const removed3 = treeMultimap.delete(3, undefined, true);
+    const removed3 = treeMultimap.delete(3, true);
     expect(removed3 instanceof Array);
     expect(removed3[0]);
     expect(removed3[0].deleted);
@@ -196,7 +196,7 @@ describe('AVLTreeMultiMap operations test1', () => {
     expect(treeMultimap.isAVLBalanced()).toBe(true);
     expect(treeMultimap.getHeight()).toBe(3);
 
-    const removed8 = treeMultimap.delete(8, undefined, true);
+    const removed8 = treeMultimap.delete(8, true);
     expect(removed8 instanceof Array);
     expect(removed8[0]);
     expect(removed8[0].deleted);
@@ -204,17 +204,17 @@ describe('AVLTreeMultiMap operations test1', () => {
     expect(treeMultimap.isAVLBalanced()).toBe(true);
     expect(treeMultimap.getHeight()).toBe(3);
 
-    const removed6 = treeMultimap.delete(6, undefined, true);
+    const removed6 = treeMultimap.delete(6, true);
     expect(removed6 instanceof Array);
     expect(removed6[0]);
     expect(removed6[0].deleted);
     if (removed6[0].deleted) expect(removed6[0].deleted.key).toBe(6);
-    expect(treeMultimap.delete(6, undefined, true).length).toBe(0);
+    expect(treeMultimap.delete(6, true).length).toBe(0);
     expect(treeMultimap.isAVLBalanced()).toBe(true);
 
     expect(treeMultimap.getHeight()).toBe(2);
 
-    const removed7 = treeMultimap.delete(7, undefined, true);
+    const removed7 = treeMultimap.delete(7, true);
     expect(removed7 instanceof Array);
     expect(removed7[0]);
     expect(removed7[0].deleted);
@@ -222,7 +222,7 @@ describe('AVLTreeMultiMap operations test1', () => {
     expect(treeMultimap.isAVLBalanced()).toBe(true);
     expect(treeMultimap.getHeight()).toBe(2);
 
-    const removed9 = treeMultimap.delete(9, undefined, true);
+    const removed9 = treeMultimap.delete(9, true);
     expect(removed9 instanceof Array);
     expect(removed9[0]);
     expect(removed9[0].deleted);
@@ -230,7 +230,7 @@ describe('AVLTreeMultiMap operations test1', () => {
     expect(treeMultimap.isAVLBalanced()).toBe(true);
     expect(treeMultimap.getHeight()).toBe(2);
 
-    const removed14 = treeMultimap.delete(14, undefined, true);
+    const removed14 = treeMultimap.delete(14, true);
     expect(removed14 instanceof Array);
     expect(removed14[0]);
     expect(removed14[0].deleted);
@@ -331,13 +331,13 @@ describe('AVLTreeMultiMap operations test recursively1', () => {
     const nodeId10 = treeMultimap.getNode(10);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = treeMultimap.getNode(9, node => node.value);
+    const nodeVal9 = treeMultimap.getNode(node => node.value === 9);
     expect(nodeVal9?.key).toBe(9);
 
-    const nodesByCount1 = treeMultimap.getNodes(1, node => node.count);
+    const nodesByCount1 = treeMultimap.getNodes(node => node.count === 1);
     expect(nodesByCount1.length).toBe(14);
 
-    const nodesByCount2 = treeMultimap.getNodes(2, node => node.count);
+    const nodesByCount2 = treeMultimap.getNodes(node => node.count === 2);
     expect(nodesByCount2.length).toBe(2);
     const leftMost = treeMultimap.getLeftMost();
     expect(leftMost).toBe(1);
@@ -347,7 +347,7 @@ describe('AVLTreeMultiMap operations test recursively1', () => {
     expect(minNodeBySpecificNode?.key).toBe(15);
 
     let subTreeSum = 0;
-    node15 && treeMultimap.dfs(node => (subTreeSum += node.key), 'PRE', 15);
+    if (node15) treeMultimap.dfs(node => (subTreeSum += node.key), 'PRE', 15);
     expect(subTreeSum).toBe(31);
     let lesserSum = 0;
     treeMultimap.lesserOrGreaterTraverse((node: AVLTreeMultiMapNode<number>) => (lesserSum += node.key), -1, 10);
@@ -379,7 +379,7 @@ describe('AVLTreeMultiMap operations test recursively1', () => {
     expect(bfsNodesAfterBalanced[0].key).toBe(8);
     expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
 
-    const removed11 = treeMultimap.delete(11, undefined, true);
+    const removed11 = treeMultimap.delete(11, true);
     expect(removed11 instanceof Array);
     expect(removed11[0]);
     expect(removed11[0].deleted);
@@ -390,7 +390,7 @@ describe('AVLTreeMultiMap operations test recursively1', () => {
 
     expect(treeMultimap.getHeight(15)).toBe(1);
 
-    const removed1 = treeMultimap.delete(1, undefined, true);
+    const removed1 = treeMultimap.delete(1, true);
     expect(removed1 instanceof Array);
     expect(removed1[0]);
     expect(removed1[0].deleted);
@@ -400,7 +400,7 @@ describe('AVLTreeMultiMap operations test recursively1', () => {
 
     expect(treeMultimap.getHeight()).toBe(4);
 
-    const removed4 = treeMultimap.delete(4, undefined, true);
+    const removed4 = treeMultimap.delete(4, true);
     expect(removed4 instanceof Array);
     expect(removed4[0]);
     expect(removed4[0].deleted);
@@ -409,7 +409,7 @@ describe('AVLTreeMultiMap operations test recursively1', () => {
     expect(treeMultimap.isAVLBalanced()).toBe(true);
     expect(treeMultimap.getHeight()).toBe(4);
 
-    const removed10 = treeMultimap.delete(10, undefined, true);
+    const removed10 = treeMultimap.delete(10, true);
     expect(removed10 instanceof Array);
     expect(removed10[0]);
     expect(removed10[0].deleted);
@@ -418,7 +418,7 @@ describe('AVLTreeMultiMap operations test recursively1', () => {
 
     expect(treeMultimap.getHeight()).toBe(3);
 
-    const removed15 = treeMultimap.delete(15, undefined, true);
+    const removed15 = treeMultimap.delete(15, true);
     expect(removed15 instanceof Array);
     expect(removed15[0]);
     expect(removed15[0].deleted);
@@ -427,7 +427,7 @@ describe('AVLTreeMultiMap operations test recursively1', () => {
     expect(treeMultimap.isAVLBalanced()).toBe(true);
     expect(treeMultimap.getHeight()).toBe(3);
 
-    const removed5 = treeMultimap.delete(5, undefined, true);
+    const removed5 = treeMultimap.delete(5, true);
     expect(removed5 instanceof Array);
     expect(removed5[0]);
     expect(removed5[0].deleted);
@@ -436,7 +436,7 @@ describe('AVLTreeMultiMap operations test recursively1', () => {
     expect(treeMultimap.isAVLBalanced()).toBe(true);
     expect(treeMultimap.getHeight()).toBe(3);
 
-    const removed13 = treeMultimap.delete(13, undefined, true);
+    const removed13 = treeMultimap.delete(13, true);
     expect(removed13 instanceof Array);
     expect(removed13[0]);
     expect(removed13[0].deleted);
@@ -444,7 +444,7 @@ describe('AVLTreeMultiMap operations test recursively1', () => {
     expect(treeMultimap.isAVLBalanced()).toBe(true);
     expect(treeMultimap.getHeight()).toBe(3);
 
-    const removed3 = treeMultimap.delete(3, undefined, true);
+    const removed3 = treeMultimap.delete(3, true);
     expect(removed3 instanceof Array);
     expect(removed3[0]);
     expect(removed3[0].deleted);
@@ -452,7 +452,7 @@ describe('AVLTreeMultiMap operations test recursively1', () => {
     expect(treeMultimap.isAVLBalanced()).toBe(true);
     expect(treeMultimap.getHeight()).toBe(3);
 
-    const removed8 = treeMultimap.delete(8, undefined, true);
+    const removed8 = treeMultimap.delete(8, true);
     expect(removed8 instanceof Array);
     expect(removed8[0]);
     expect(removed8[0].deleted);
@@ -460,17 +460,17 @@ describe('AVLTreeMultiMap operations test recursively1', () => {
     expect(treeMultimap.isAVLBalanced()).toBe(true);
     expect(treeMultimap.getHeight()).toBe(3);
 
-    const removed6 = treeMultimap.delete(6, undefined, true);
+    const removed6 = treeMultimap.delete(6, true);
     expect(removed6 instanceof Array);
     expect(removed6[0]);
     expect(removed6[0].deleted);
     if (removed6[0].deleted) expect(removed6[0].deleted.key).toBe(6);
-    expect(treeMultimap.delete(6, undefined, true).length).toBe(0);
+    expect(treeMultimap.delete(6, true).length).toBe(0);
     expect(treeMultimap.isAVLBalanced()).toBe(true);
 
     expect(treeMultimap.getHeight()).toBe(2);
 
-    const removed7 = treeMultimap.delete(7, undefined, true);
+    const removed7 = treeMultimap.delete(7, true);
     expect(removed7 instanceof Array);
     expect(removed7[0]);
     expect(removed7[0].deleted);
@@ -478,7 +478,7 @@ describe('AVLTreeMultiMap operations test recursively1', () => {
     expect(treeMultimap.isAVLBalanced()).toBe(true);
     expect(treeMultimap.getHeight()).toBe(2);
 
-    const removed9 = treeMultimap.delete(9, undefined, true);
+    const removed9 = treeMultimap.delete(9, true);
     expect(removed9 instanceof Array);
     expect(removed9[0]);
     expect(removed9[0].deleted);
@@ -486,7 +486,7 @@ describe('AVLTreeMultiMap operations test recursively1', () => {
     expect(treeMultimap.isAVLBalanced()).toBe(true);
     expect(treeMultimap.getHeight()).toBe(2);
 
-    const removed14 = treeMultimap.delete(14, undefined, true);
+    const removed14 = treeMultimap.delete(14, true);
     expect(removed14 instanceof Array);
     expect(removed14[0]);
     expect(removed14[0].deleted);
@@ -556,7 +556,7 @@ describe('AVLTreeMultiMap Performance test', function () {
   it(`Observe the time consumption of AVLTreeMultiMap.dfs be good`, function () {
     const startDFS = performance.now();
     const dfs = treeMS.dfs(node => node);
-    isDebug && console.log('---bfs', performance.now() - startDFS, dfs.length);
+    if (isDebug) console.log('---bfs', performance.now() - startDFS, dfs.length);
   });
 
   it('Should the time consumption of lesserOrGreaterTraverse fitting O(n log n)', function () {
@@ -564,10 +564,10 @@ describe('AVLTreeMultiMap Performance test', function () {
     for (let i = 0; i < inputSize; i++) {
       treeMS.add(i);
     }
-    isDebug && console.log('---add', performance.now() - start);
+    if (isDebug) console.log('---add', performance.now() - start);
     const startL = performance.now();
     treeMS.lesserOrGreaterTraverse(node => (node.count += 1), -1, inputSize / 2);
-    isDebug && console.log('---lesserOrGreaterTraverse', performance.now() - startL);
+    if (isDebug) console.log('---lesserOrGreaterTraverse', performance.now() - startL);
   });
 
   it('should the clone method', () => {

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

@@ -24,7 +24,7 @@ describe('AVL Tree Test', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && tree.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) tree.dfs(node => (subTreeSum += node.key), 'PRE', node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -132,7 +132,7 @@ describe('AVL Tree Test recursively', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && tree.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) tree.dfs(node => (subTreeSum += node.key), 'PRE', node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;

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

@@ -169,8 +169,8 @@ describe('BinaryTree', () => {
     expect(tree.has(4)).toBe(false);
     const node4 = tree.getNode(4);
     expect(tree.has(node4)).toBe(false);
-    expect(tree.has(node4, node => node)).toBe(false);
-    expect(tree.has('3', node => node.value?.toString())).toBe(true);
+    expect(tree.has(node => node === node4)).toBe(false);
+    expect(tree.has(node => node.value?.toString() === '3')).toBe(true);
   });
 
   it('should the clone method work fine', () => {
@@ -296,8 +296,9 @@ describe('BinaryTree', () => {
   });
 
   it('should isSubtreeBST', () => {
+    expect(tree.toVisual()).toBe('');
     tree.addMany([4, 2, 6, 1, 3, 5, 7, 4]);
-    expect(tree.print()).toBe(
+    expect(tree.toVisual()).toBe(
       '    ___4___    \n' +
         '   /       \\   \n' +
         '  _2_     _6_  \n' +
@@ -305,12 +306,26 @@ describe('BinaryTree', () => {
         ' 1   3   5   7 \n' +
         '               \n'
     );
+    const visualized = tree.toVisual(undefined, { isShowUndefined: true, isShowNull: true, isShowRedBlackNIL: true });
+    expect(visualized).toBe(
+      'U for undefined\n' +
+        '      N for null\n' +
+        '      S for Sentinel Node(NIL)\n' +
+        '              _______4_______        \n' +
+        '       /               \\       \n' +
+        '    ___2___         ___6___    \n' +
+        '   /       \\       /       \\   \n' +
+        '  _1_     _3_     _5_     _7_  \n' +
+        ' /   \\   /   \\   /   \\   /   \\ \n' +
+        ' U   U   U   U   U   U   U   U \n' +
+        '                               \n'
+    );
 
     expect(tree.isBST(tree.getNode(4), 'RECURSIVE')).toBe(true);
     expect(tree.isBST(tree.getNode(4), 'ITERATIVE')).toBe(true);
-    expect(tree.getNodes(2, undefined, false, null)).toEqual([]);
+    expect(tree.getNodes(2, false, null)).toEqual([]);
     expect(tree.getNodes(undefined)).toEqual([]);
-    expect(tree.getNodes(tree.getNodeByKey(2), undefined, false, tree.root)).toEqual([tree.getNodeByKey(2)]);
+    expect(tree.getNodes(tree.getNodeByKey(2), false, tree.root)).toEqual([tree.getNodeByKey(2)]);
   });
 
   describe('should isKey', () => {
@@ -472,13 +487,20 @@ describe('BinaryTree', () => {
   });
 
   it('should isLeaf', () => {
+    expect(tree.getLeftMost()).toBe(undefined);
+    expect(tree.getRightMost()).toBe(undefined);
     tree.addMany([4, 2, 6, 1, 3, 5, 7, 4]);
     const leftMost = tree.getLeftMost();
     expect(tree.isLeaf(leftMost)).toBe(true);
     expect(tree.isLeaf(null)).toBe(true);
+    const rightMost = tree.getRightMost();
+    expect(tree.isLeaf(rightMost)).toBe(true);
+    expect(tree.isLeaf(null)).toBe(true);
   });
 
   it('should tree traverse', () => {
+    expect(tree.dfs()).toEqual([]);
+    expect([...tree.values()]).toEqual([]);
     tree.addMany([4, 2, 6, null, 1, 3, null, 5, null, 7]);
     expect(tree.dfs(node => node.key, 'PRE', undefined, 'ITERATIVE')).toEqual([4, 2, 1, 5, 6, 3, 7]);
     expect(tree.dfs(node => (node !== null ? node.key : null), 'PRE', undefined, 'ITERATIVE', false)).toEqual([
@@ -666,6 +688,7 @@ describe('BinaryTree', () => {
 
   it('should duplicated nodes just replace the node exists', function () {
     tree.clear();
+    expect(tree.bfs()).toEqual([]);
     tree.addMany([-10, -10, -10, 9, 9, 20, null, null, 15, 7, 8, null, 2, null, 6, null, null, 8, 8, 8]);
 
     expect(tree.bfs(node => (node ? node.key : null), undefined, undefined, true)).toEqual([
@@ -894,21 +917,9 @@ describe('BinaryTree traversals', () => {
     expect(tree.dfs(node => node.key, 'PRE', tree.root, 'RECURSIVE')).toEqual([
       35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55
     ]);
-    expect(tree.dfs(node => node, 'PRE', tree.root, '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, '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, 'RECURSIVE', true).map(node => (node ? node.key : null))).toEqual([
       35,
       20,
@@ -953,8 +964,9 @@ describe('BinaryTree traversals', () => {
       [15, 29, null, 50],
       [null, 16, 28, 30, 45, 55]
     ]);
-  })
-
+    tree.clear();
+    expect(tree.listLevels()).toEqual([]);
+  });
 });
 
 describe('BinaryTree', () => {
@@ -1030,6 +1042,7 @@ describe('BinaryTree', () => {
   });
 
   it('should get the height of the tree', () => {
+    expect(tree.getMinHeight()).toBe(-1);
     tree.add([5, 'A']);
     tree.add(3, 'B');
     tree.add([7, 'C']);
@@ -1088,6 +1101,15 @@ describe('BinaryTree', () => {
     expect(tree.getNode(3)).toBe(null);
   });
 
+  it('should getPathToRoot', () => {
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
+
+    expect(tree.getPathToRoot(undefined, 7)).toEqual([5, 7]);
+    expect(tree.getPathToRoot(undefined, 1)).toEqual([]);
+  });
+
   it('should check if the tree is perfectly balanced', () => {
     tree.add([5, 'A']);
     tree.add([3, 'B']);
@@ -1108,17 +1130,17 @@ describe('BinaryTree', () => {
     tree.add([2, 'B']);
     tree.add([null, 'null']);
 
-    const nodes = tree.getNodes('B', node => node.value);
+    const nodes = tree.getNodes(node => node.value === 'B');
 
     expect(nodes.length).toBe(1);
     expect(nodes[0].key).toBe(2);
 
-    const nodesRec = tree.getNodes('B', node => node.value, false, tree.root, 'RECURSIVE');
+    const nodesRec = tree.getNodes(node => node.value === 'B', false, tree.root, 'RECURSIVE');
 
     expect(nodesRec.length).toBe(1);
     expect(nodesRec[0].key).toBe(2);
 
-    const nodesItr = tree.getNodes('B', node => node.value, false, tree.root, 'ITERATIVE');
+    const nodesItr = tree.getNodes(node => node.value === 'B', false, tree.root, 'ITERATIVE');
 
     expect(nodesItr.length).toBe(1);
     expect(nodesItr[0].key).toBe(2);
@@ -1147,7 +1169,8 @@ describe('BinaryTree', () => {
 
     const result = tree.morris();
     expect(result).toEqual([3, 5, 7]);
-    // Add assertions for the result of Morris traversal
+    tree.clear();
+    expect(tree.morris()).toEqual([]);
   });
 
   it('should perform delete all', () => {
@@ -1246,6 +1269,8 @@ describe('BinaryTree iterative methods test', () => {
   it('should leaves', () => {
     const leaves = binaryTree.leaves();
     expect(leaves).toEqual([2, 3]);
+    binaryTree.clear();
+    expect(binaryTree.leaves()).toEqual([]);
   });
 
   it('should iterative method return undefined when the node is null', () => {

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

@@ -69,7 +69,7 @@ describe('BST operations test', () => {
     const nodeId10 = bst.getNode(10);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = bst.getNode(9, node => node.value);
+    const nodeVal9 = bst.getNode(node => node.value === 9);
     expect(nodeVal9?.key).toBe(9);
 
     const leftMost = bst.getLeftMost();
@@ -81,8 +81,11 @@ describe('BST operations test', () => {
     const minNodeBySpecificNode = node15 && bst.getLeftMost(node => node, node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
 
+    const nodes = bst.getNodes(node => node.value === 15);
+    expect(nodes.map(node => node.key)).toEqual([15]);
+
     let subTreeSum = 0;
-    node15 && bst.dfs(node => (subTreeSum += node.key), 'PRE', 15);
+    if (node15) bst.dfs(node => (subTreeSum += node.key), 'PRE', 15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -231,6 +234,9 @@ describe('BST operations test', () => {
     expect(bfsNodes[0].key).toBe(2);
     expect(bfsNodes[1].key).toBe(12);
     expect(bfsNodes[2].key).toBe(16);
+    bst.clear();
+    expect(bst.perfectlyBalance()).toBe(false);
+    expect(bst.isAVLBalanced()).toBe(true);
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
@@ -288,7 +294,7 @@ describe('BST operations test', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && objBST.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) objBST.dfs(node => (subTreeSum += node.key), 'PRE', node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -484,7 +490,7 @@ describe('BST operations test recursively', () => {
     expect(bst.get(10)).toBe(undefined);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = bst.getNode(9, node => node.value);
+    const nodeVal9 = bst.getNode(node => node.value === 9);
     expect(nodeVal9?.key).toBe(undefined);
 
     const leftMost = bst.getLeftMost();
@@ -495,7 +501,7 @@ describe('BST operations test recursively', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && bst.dfs(node => (subTreeSum += node.key), 'PRE', 15);
+    if (node15) bst.dfs(node => (subTreeSum += node.key), 'PRE', 15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -702,7 +708,7 @@ describe('BST operations test recursively', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && objBST.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) objBST.dfs(node => (subTreeSum += node.key), 'PRE', node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -869,6 +875,28 @@ describe('BST operations test recursively', () => {
     expect(numBST.size).toBe(0);
   });
 
+  it('should listLevels', () => {
+    const bst = new BST<number>();
+    bst.addMany([2, 4, 5, 3, 1]);
+    expect(bst.size).toBe(5);
+    bst.delete(1);
+    bst.delete(5);
+    const levelKeys = bst.listLevels();
+    expect(levelKeys).toEqual([[3], [2, 4]]);
+  });
+
+  it('should lesserOrGreaterTraverse', () => {
+    const bst = new BST<number>();
+    const levelKeys = bst.lesserOrGreaterTraverse();
+    expect(levelKeys).toEqual([]);
+    bst.addMany([2, 4, 5, 3, 1]);
+    expect(bst.size).toBe(5);
+    bst.delete(1);
+    bst.delete(5);
+    const levelKeys1 = bst.lesserOrGreaterTraverse();
+    expect(levelKeys1).toEqual([2]);
+  });
+
   it('should the clone method', () => {
     function checkTreeStructure(bst: BST<string, number>) {
       expect(bst.size).toBe(4);
@@ -972,7 +1000,7 @@ describe('BST Performance test', function () {
   it(`Observe the time consumption of BST.dfs be good`, function () {
     const startDFS = performance.now();
     const dfs = bst.dfs(node => node);
-    isDebug && console.log('---bfs', performance.now() - startDFS, dfs.length);
+    if (isDebug) console.log('---bfs', performance.now() - startDFS, dfs.length);
   });
 
   it('Should the time consumption of lesserOrGreaterTraverse fitting O(n log n)', function () {
@@ -982,16 +1010,16 @@ describe('BST Performance test', function () {
     }
     const start = performance.now();
     bst.addMany(nodes);
-    isDebug && console.log('---add', performance.now() - start);
+    if (isDebug) console.log('---add', performance.now() - start);
     const startL = performance.now();
     bst.lesserOrGreaterTraverse(
       node => {
-        node.key - 1;
+        node.key -= 1;
       },
       -1,
       inputSize / 2
     );
-    isDebug && console.log('---lesserOrGreaterTraverse', performance.now() - startL);
+    if (isDebug) console.log('---lesserOrGreaterTraverse', performance.now() - startL);
   });
 
   it('Should the time consumption of listLevels fitting well', function () {
@@ -1001,11 +1029,11 @@ describe('BST Performance test', function () {
     }
     const start = performance.now();
     bst.addMany(nodes);
-    isDebug && console.log('---add', performance.now() - start);
+    if (isDebug) console.log('---add', performance.now() - start);
     const startL = performance.now();
     const arr: number[][] = bst.listLevels(node => node.key);
-    isDebug && console.log('---listLevels', arr);
-    isDebug && console.log('---listLevels', performance.now() - startL);
+    if (isDebug) console.log('---listLevels', arr);
+    if (isDebug) console.log('---listLevels', performance.now() - startL);
   });
 
   it('should the lastKey of a BST to be the largest key', function () {

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

@@ -6,18 +6,13 @@ describe('Overall BinaryTree Test', () => {
     bst.add(11);
     bst.add(3);
     bst.addMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5], undefined, false);
-    bst.size === 16; // true
     expect(bst.size).toBe(16); // true
     bst.has(6); // true
     expect(bst.has(6)).toBe(true); // true
-    bst.getHeight(6) === 2; // true
-    bst.getHeight() === 5; // true
-    bst.getDepth(6) === 3; // true
     expect(bst.getHeight(6)).toBe(2); // true
     expect(bst.getHeight()).toBe(5); // true
     expect(bst.getDepth(6)).toBe(3); // true
     const leftMost = bst.getLeftMost();
-    leftMost?.key === 1; // true
     expect(leftMost).toBe(1);
     bst.delete(6);
     bst.getNode(6); // undefined
@@ -26,7 +21,6 @@ describe('Overall BinaryTree Test', () => {
     expect(bst.isAVLBalanced()).toBe(true);
     const bfsIDs: number[] = [];
     bst.bfs(node => bfsIDs.push(node.key));
-    bfsIDs[0] === 11; // true
     expect(bfsIDs[0]).toBe(11);
 
     const objBST = new BST<number, { key: number; keyA: number }>();