data-structure-typed 1.52.5 → 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([
@@ -848,110 +871,102 @@ describe('BinaryTree toEntryFn', () => {
 });
 
 describe('BinaryTree traversals', () => {
-  const tree = new BinaryTree<number>();
+  it('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, '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, '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, '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, '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, '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, '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]);
+    expect(tree.dfs(node => node.key, 'POST', tree.root, 'RECURSIVE')).toEqual([
+      16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35
+    ]);
+    expect(tree.bfs(node => node.key, tree.root, 'RECURSIVE')).toEqual([35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55]);
+    expect(tree.bfs(node => node.key, tree.root, 'ITERATIVE')).toEqual([35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55]);
+
+    expect(tree.listLevels(node => node.key)).toEqual([[35], [20, 40], [15, 29, 50], [16, 28, 30, 45, 55]]);
 
-  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, '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, '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, '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, '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, '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 ? 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, '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]);
-  expect(tree.dfs(node => node.key, 'POST', tree.root, 'RECURSIVE')).toEqual([
-    16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35
-  ]);
-  expect(tree.bfs(node => node.key, tree.root, 'RECURSIVE')).toEqual([35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55]);
-  expect(tree.bfs(node => node.key, tree.root, 'ITERATIVE')).toEqual([35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55]);
-
-  expect(tree.listLevels(node => node.key)).toEqual([[35], [20, 40], [15, 29, 50], [16, 28, 30, 45, 55]]);
-
-  expect(tree.listLevels(node => node.key, tree.root, 'RECURSIVE')).toEqual([
-    [35],
-    [20, 40],
-    [15, 29, 50],
-    [16, 28, 30, 45, 55]
-  ]);
-  expect(tree.listLevels(node => (node ? node.key : null), tree.root, 'ITERATIVE', true)).toEqual([
-    [35],
-    [20, 40],
-    [15, 29, null, 50],
-    [null, 16, 28, 30, 45, 55]
-  ]);
-  expect(tree.listLevels(node => (node ? node.key : null), tree.root, 'RECURSIVE', true)).toEqual([
-    [35],
-    [20, 40],
-    [15, 29, null, 50],
-    [null, 16, 28, 30, 45, 55]
-  ]);
+    expect(tree.listLevels(node => node.key, tree.root, 'RECURSIVE')).toEqual([
+      [35],
+      [20, 40],
+      [15, 29, 50],
+      [16, 28, 30, 45, 55]
+    ]);
+    expect(tree.listLevels(node => (node ? node.key : null), tree.root, 'ITERATIVE', true)).toEqual([
+      [35],
+      [20, 40],
+      [15, 29, null, 50],
+      [null, 16, 28, 30, 45, 55]
+    ]);
+    expect(tree.listLevels(node => (node ? node.key : null), tree.root, 'RECURSIVE', true)).toEqual([
+      [35],
+      [20, 40],
+      [15, 29, null, 50],
+      [null, 16, 28, 30, 45, 55]
+    ]);
+    tree.clear();
+    expect(tree.listLevels()).toEqual([]);
+  });
 });
 
 describe('BinaryTree', () => {
@@ -1027,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']);
@@ -1085,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']);
@@ -1105,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);
@@ -1144,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', () => {
@@ -1243,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', () => {