data-structure-typed 1.43.1 → 1.43.3

package/test/performance/data-structures/queue/deque.test.ts

@@ -2,30 +2,29 @@ import {Deque} from '../../../../src';
 import {Deque as CDeque} from 'js-sdsl';
 import * as Benchmark from 'benchmark';
 import {magnitude} from '../../../utils';
-import {isCompetitor} from "../../../config";
+import {isCompetitor} from '../../../config';
 
 export const suite = new Benchmark.Suite();
 const {LINEAR} = magnitude;
 
-suite
-  .add(`${LINEAR.toLocaleString()} push`, () => {
-    const deque = new Deque<number>();
-    for (let i = 0; i < LINEAR; i++) {
-      deque.push(i);
-    }
-  })
-  if (isCompetitor) {
-    suite.add(`${LINEAR.toLocaleString()} competitor push`, () => {
-      const deque = new CDeque<number>();
-      for (let i = 0; i < LINEAR; i++) {
-        deque.pushBack(i);
-      }
-    })
+suite.add(`${LINEAR.toLocaleString()} push`, () => {
+  const deque = new Deque<number>();
+  for (let i = 0; i < LINEAR; i++) {
+    deque.push(i);
   }
-  suite.add(`${LINEAR.toLocaleString()} shift`, () => {
-    const deque = new Deque<number>();
+});
+if (isCompetitor) {
+  suite.add(`${LINEAR.toLocaleString()} competitor push`, () => {
+    const deque = new CDeque<number>();
     for (let i = 0; i < LINEAR; i++) {
-      deque.push(i);
-      deque.shift();
+      deque.pushBack(i);
     }
   });
+}
+suite.add(`${LINEAR.toLocaleString()} shift`, () => {
+  const deque = new Deque<number>();
+  for (let i = 0; i < LINEAR; i++) {
+    deque.push(i);
+    deque.shift();
+  }
+});

package/test/performance/data-structures/queue/queue.test.ts

@@ -2,35 +2,34 @@ import {Queue} from '../../../../src';
 import {Queue as CQueue} from 'js-sdsl';
 import * as Benchmark from 'benchmark';
 import {magnitude} from '../../../utils';
-import {isCompetitor} from "../../../config";
+import {isCompetitor} from '../../../config';
 
 const suite = new Benchmark.Suite();
 const {LINEAR} = magnitude;
 
-suite
-  .add(`${LINEAR.toLocaleString()} push`, () => {
-    const queue = new Queue<number>();
+suite.add(`${LINEAR.toLocaleString()} push`, () => {
+  const queue = new Queue<number>();
 
-    for (let i = 0; i < LINEAR; i++) {
-      queue.push(i);
-    }
-  })
-  if (isCompetitor) {
-    suite.add(`${LINEAR.toLocaleString()} competitor push`, () => {
-      const queue = new CQueue<number>();
-
-      for (let i = 0; i < LINEAR; i++) {
-        queue.push(i);
-      }
-    })
+  for (let i = 0; i < LINEAR; i++) {
+    queue.push(i);
   }
-  suite.add(`${LINEAR.toLocaleString()} push & shift`, () => {
-    const queue = new Queue<number>();
+});
+if (isCompetitor) {
+  suite.add(`${LINEAR.toLocaleString()} competitor push`, () => {
+    const queue = new CQueue<number>();
 
     for (let i = 0; i < LINEAR; i++) {
       queue.push(i);
-      queue.shift();
     }
   });
+}
+suite.add(`${LINEAR.toLocaleString()} push & shift`, () => {
+  const queue = new Queue<number>();
+
+  for (let i = 0; i < LINEAR; i++) {
+    queue.push(i);
+    queue.shift();
+  }
+});
 
 export {suite};

package/test/performance/data-structures/stack/stack.test.ts

@@ -2,19 +2,18 @@ import {Stack} from '../../../../src';
 import {Stack as CStack} from 'js-sdsl';
 import * as Benchmark from 'benchmark';
 import {magnitude} from '../../../utils';
-import {isCompetitor} from "../../../config";
+import {isCompetitor} from '../../../config';
 
 const suite = new Benchmark.Suite();
 const {LINEAR} = magnitude;
 
-suite
-  .add(`${LINEAR.toLocaleString()} push`, () => {
-    const stack = new Stack<number>();
+suite.add(`${LINEAR.toLocaleString()} push`, () => {
+  const stack = new Stack<number>();
 
-    for (let i = 0; i < LINEAR; i++) {
-      stack.push(i);
-    }
-  })
+  for (let i = 0; i < LINEAR; i++) {
+    stack.push(i);
+  }
+});
 if (isCompetitor) {
   suite.add(`${LINEAR.toLocaleString()} competitor push`, () => {
     const queue = new CStack<number>();
@@ -22,7 +21,7 @@ if (isCompetitor) {
     for (let i = 0; i < LINEAR; i++) {
       queue.push(i);
     }
-  })
+  });
 }
 suite.add(`${LINEAR.toLocaleString()} push & pop`, () => {
   const queue = new Stack<number>();
@@ -33,7 +32,7 @@ suite.add(`${LINEAR.toLocaleString()} push & pop`, () => {
   for (let i = 0; i < LINEAR; i++) {
     queue.pop();
   }
-})
+});
 if (isCompetitor) {
   suite.add(`${LINEAR.toLocaleString()} competitor push & pop`, () => {
     const queue = new CStack<number>();
@@ -44,7 +43,7 @@ if (isCompetitor) {
     for (let i = 0; i < LINEAR; i++) {
       queue.pop();
     }
-  })
+  });
 }
 
 export {suite};

package/test/performance/reportor.ts

@@ -5,7 +5,9 @@ import * as fastGlob from 'fast-glob';
 import {Color, numberFix, render} from '../utils';
 import {PerformanceTest} from './types';
 
-const reportDistPath = 'benchmark';
+const parentDirectory = path.resolve(__dirname, '../..');
+const reportDistPath = path.join(parentDirectory, 'benchmark');
+
 const testDir = path.join(__dirname, 'data-structures');
 const testFiles = fastGlob.sync(path.join(testDir, '**', '*.test.ts'));
 
@@ -109,7 +111,6 @@ const composeReport = () => {
 };
 
 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
   fs.readFile(filePath, 'utf8', (err, data) => {
     if (err) {
@@ -172,9 +173,7 @@ performanceTests.forEach(item => {
         console.log(
           // `Files: ${GREEN}${testFileCount}${END} `,
           // `Suites: ${GREEN}${performanceTests.length}${END} `,
-          `Suites Progress: ${isDone ? GREEN : YELLOW}${completedCount}${END}/${isDone ? GREEN : YELLOW}${
-            performanceTests.length
-          }${END}`,
+          `Suites Progress: ${isDone ? GREEN : YELLOW}${completedCount}${END}/${isDone ? GREEN : YELLOW}${performanceTests.length}${END}`,
           `Time: ${isTimeWarn ? YELLOW : GREEN}${runTime}s${END}`
         );
         if (isDone) {

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

@@ -285,5 +285,4 @@ describe('AVLTree', () => {
       expect(bfsRes[0]?.key).toBe(2);
     });
   });
-
 });

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

@@ -1,6 +1,6 @@
 import {BinaryTree, BinaryTreeNode, IterationType} from '../../../../src';
-import {getRandomIntArray} from "../../../utils";
-import {FamilyPosition} from "binary-tree-typed";
+import {getRandomIntArray} from '../../../utils';
+import {FamilyPosition} from 'binary-tree-typed';
 // import {isDebugTest} from '../../../config';
 
 // const isDebug = isDebugTest;
@@ -72,7 +72,6 @@ describe('BinaryTreeNode', () => {
     expect(leftChild.familyPosition).toBe('ROOT_LEFT');
     rightChild.left = new BinaryTreeNode<number>(5);
     expect(rightChild.familyPosition).toBe('ROOT_RIGHT');
-
   });
 
   it('should determine only right child family position correctly', () => {
@@ -106,8 +105,8 @@ describe('BinaryTree', () => {
   });
 
   it('should delete nodes', () => {
-    expect(tree.getHeight(tree.root, IterationType.ITERATIVE)).toBe(-1)
-    expect(tree.getMinHeight()).toBe(-1)
+    expect(tree.getHeight(tree.root, IterationType.ITERATIVE)).toBe(-1);
+    expect(tree.getMinHeight()).toBe(-1);
     const node = tree.add(1);
     expect(tree.size).toBe(1);
 
@@ -117,7 +116,6 @@ describe('BinaryTree', () => {
     tree.add(rightChild);
     const root = tree.root;
 
-
     expect(leftChild.familyPosition).toBe('LEFT');
     tree.add(null);
     tree.add(new BinaryTreeNode<number>(4));
@@ -128,15 +126,14 @@ describe('BinaryTree', () => {
     expect(rightChild.familyPosition).toBe('ROOT_RIGHT');
 
     tree.delete(new BinaryTreeNode<number>(200));
-    tree.delete(rightChild)
+    tree.delete(rightChild);
 
     if (node) {
       const result = tree.delete(node);
       expect(result).toHaveLength(1);
       expect(tree.size).toBe(3);
-      expect(tree.getMinHeight(tree.root, IterationType.RECURSIVE)).toBe(1)
+      expect(tree.getMinHeight(tree.root, IterationType.RECURSIVE)).toBe(1);
     }
-
   });
 
   it('should add and find nodes', () => {
@@ -155,11 +152,10 @@ describe('BinaryTree', () => {
     expect(tree.has('3', node => node.value?.toString())).toBe(true);
   });
 
-
   it('should be a balance tree after malicious manipulation', () => {
     tree.add(3);
     tree.add(12);
-    tree.addMany(getRandomIntArray(100, 1, 100))
+    tree.addMany(getRandomIntArray(100, 1, 100));
     tree.add(10);
 
     expect(tree.isPerfectlyBalanced()).toBe(true);
@@ -238,20 +234,16 @@ describe('BinaryTree', () => {
 
     expect(tree.isSubtreeBST(tree.getNode(4), IterationType.RECURSIVE)).toBe(true);
     expect(tree.isSubtreeBST(tree.getNode(4), IterationType.ITERATIVE)).toBe(true);
-    expect(tree.getNodes(2, undefined, false, null)).toEqual([])
-    expect(tree.getNodes(tree.getNodeByKey(2), undefined, false, tree.root)).toEqual([tree.getNodeByKey(2)])
+    expect(tree.getNodes(2, undefined, false, null)).toEqual([]);
+    expect(tree.getNodes(tree.getNodeByKey(2), undefined, false, tree.root)).toEqual([tree.getNodeByKey(2)]);
   });
 
   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 ? 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]);
+    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', () => {
@@ -323,46 +315,82 @@ describe('BinaryTree traversals', () => {
 
   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 ? 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.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
-      .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]);
-  expect(tree.dfs(node => node.key, 'post', tree.root, IterationType.RECURSIVE)).toEqual([
-    16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35
+  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.key, tree.root, IterationType.RECURSIVE)).toEqual([
+  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.key, tree.root, IterationType.ITERATIVE)).toEqual([
+  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 ? 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]);
+  expect(tree.dfs(node => node.key, 'post', tree.root, IterationType.RECURSIVE)).toEqual([16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35]);
+  expect(tree.bfs(node => node.key, tree.root, IterationType.RECURSIVE)).toEqual([35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55]);
+  expect(tree.bfs(node => node.key, tree.root, IterationType.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, IterationType.RECURSIVE)).toEqual([
@@ -371,13 +399,13 @@ describe('BinaryTree traversals', () => {
     [15, 29, 50],
     [16, 28, 30, 45, 55]
   ]);
-  expect(tree.listLevels(node => (node ? node.key : null ), 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 ? node.key : null ), 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],
@@ -532,13 +560,7 @@ describe('BinaryTree', () => {
     expect(nodes.length).toBe(1);
     expect(nodes[0].key).toBe(3);
 
-    const nodesRec = tree.getNodes(
-      'B',
-      (node: BinaryTreeNode<string>) => node.value,
-      false,
-      tree.root,
-      IterationType.RECURSIVE
-    );
+    const nodesRec = tree.getNodes('B', (node: BinaryTreeNode<string>) => node.value, false, tree.root, IterationType.RECURSIVE);
 
     expect(nodesRec.length).toBe(1);
     expect(nodesRec[0].key).toBe(3);

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

@@ -843,11 +843,7 @@ describe('BST Performance test', function () {
     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]);
+    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]);
   });
 });

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

@@ -1,6 +1,7 @@
-import {IterationType, RBTNColor, RedBlackTreeNode, RedBlackTree} from '../../../../src';
-import {getRandomInt} from '../../../utils';
+import {IterationType, RBTNColor, RedBlackTree, RedBlackTreeNode} from '../../../../src';
+import {getRandomInt, getRandomIntArray, magnitude} from '../../../utils';
 import {isDebugTest} from '../../../config';
+import {OrderedMap} from 'js-sdsl';
 
 const isDebug = isDebugTest;
 
@@ -420,14 +421,10 @@ describe('RedBlackTree', () => {
     isDebug && tree.print();
 
     expect(tree.dfs()).toEqual([
-      1,   2,  3,  4,  5,  6,  7,   8,   9,
-      10,  11, 12, 13, 14, 15, 16,  17,  18,
-      19,  22, 23, 25, 28, 33, 50, 110, 111,
-      155, 225
-    ])
+      1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 22, 23, 25, 28, 33, 50, 110, 111, 155, 225
+    ]);
 
     expect(tree.isBST()).toBe(true);
-
   });
 
   it('should fix the tree after insertion and deletion', () => {
@@ -440,20 +437,14 @@ describe('RedBlackTree', () => {
 
     expect(tree.size).toBe(51);
     expect(tree.isBST()).toBe(true);
-    expect(tree.dfs( n => n.key, "in", tree.root, IterationType.ITERATIVE)).toEqual([
-      49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
-      60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
-      71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
-      82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
-      93, 94, 95, 96, 97, 98, 99
-    ])
-    expect(tree.dfs( n => n.key, "in", tree.root, IterationType.RECURSIVE)).toEqual([
-      49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
-      60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
-      71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
-      82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
-      93, 94, 95, 96, 97, 98, 99
-    ])
+    expect(tree.dfs(n => n.key, 'in', tree.root, IterationType.ITERATIVE)).toEqual([
+      49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
+      82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99
+    ]);
+    expect(tree.dfs(n => n.key, 'in', tree.root, IterationType.RECURSIVE)).toEqual([
+      49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
+      82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99
+    ]);
   });
 
   it('should fix the tree after large scale insertion and deletion', () => {
@@ -466,16 +457,34 @@ describe('RedBlackTree', () => {
 
     expect(tree.size).toBe(0);
     expect(tree.isBST()).toBe(true);
-    expect(tree.dfs( n => n.key, "in", tree.root, IterationType.ITERATIVE)).toEqual([])
+    expect(tree.dfs(n => n.key, 'in', tree.root, IterationType.ITERATIVE)).toEqual([]);
 
     tree.clear();
     for (let i = 0; i < 1000; i++) {
-      tree.add(getRandomInt(-100, 1000))
-      tree.delete(getRandomInt(-100, 1000))
+      tree.add(getRandomInt(-100, 1000));
+      tree.delete(getRandomInt(-100, 1000));
     }
 
     // TODO there is a bug when dfs the tree with NIL node
     // expect(tree.isBST()).toBe(true);
   });
+  const {HUNDRED_THOUSAND} = magnitude;
+  const arr = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND, true);
+  const competitor = new OrderedMap<number, number>();
+
+  it('should fix the tree after large scale insertion and deletion', () => {
+    tree.clear();
+    const tS = performance.now();
+    for (let i = 0; i < arr.length; i++) {
+      tree.add(arr[i]);
+    }
+    console.log(performance.now() - tS);
+
+    const cS = performance.now();
 
+    for (let i = 0; i < arr.length; i++) {
+      competitor.setElement(arr[i], arr[i]);
+    }
+    console.log(performance.now() - cS);
+  });
 });

package/test/unit/data-structures/graph/abstract-graph.test.ts

@@ -22,12 +22,12 @@ class MyEdge<E = any> extends AbstractEdge<E> {
   }
 }
 
-class MyGraph<
-  V = any,
-  E = any,
-  VO extends MyVertex<V> = MyVertex<V>,
-  EO extends MyEdge<E> = MyEdge<E>
-> extends AbstractGraph<V, E, VO, EO> {
+class MyGraph<V = any, E = any, VO extends MyVertex<V> = MyVertex<V>, EO extends MyEdge<E> = MyEdge<E>> extends AbstractGraph<
+  V,
+  E,
+  VO,
+  EO
+> {
   createVertex(key: VertexKey, value?: V): VO {
     return new MyVertex(key, value) as VO;
   }

package/test/unit/data-structures/graph/directed-graph.test.ts

@@ -126,12 +126,12 @@ class MyEdge<E = any> extends DirectedEdge<E> {
   }
 }
 
-class MyDirectedGraph<
-  V = any,
-  E = any,
-  VO extends MyVertex<V> = MyVertex<V>,
-  EO extends MyEdge<E> = MyEdge<E>
-> extends DirectedGraph<V, E, VO, EO> {
+class MyDirectedGraph<V = any, E = any, VO extends MyVertex<V> = MyVertex<V>, EO extends MyEdge<E> = MyEdge<E>> extends DirectedGraph<
+  V,
+  E,
+  VO,
+  EO
+> {
   createVertex(key: VertexKey, value: V): VO {
     return new MyVertex(key, value) as VO;
   }
@@ -351,29 +351,9 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
       expect(costs[2]).toEqual([3, 15, 38, 17, 35, Infinity, 64, Infinity, 22]);
       expect(costs[3]).toEqual([123, 135, 120, 137, 155, Infinity, 47, Infinity, 126]);
       expect(costs[4]).toEqual([133, 145, 130, 147, 165, Infinity, 57, Infinity, 136]);
-      expect(costs[5]).toEqual([
-        Infinity,
-        Infinity,
-        Infinity,
-        Infinity,
-        Infinity,
-        Infinity,
-        Infinity,
-        Infinity,
-        Infinity
-      ]);
+      expect(costs[5]).toEqual([Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity]);
       expect(costs[6]).toEqual([76, 88, 73, 90, 108, Infinity, 137, Infinity, 79]);
-      expect(costs[7]).toEqual([
-        Infinity,
-        Infinity,
-        Infinity,
-        Infinity,
-        Infinity,
-        Infinity,
-        Infinity,
-        Infinity,
-        Infinity
-      ]);
+      expect(costs[7]).toEqual([Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity]);
       expect(costs[8]).toEqual([173, 185, 170, 187, 205, Infinity, 97, Infinity, 176]);
 
       expect(predecessor).toBeInstanceOf(Array);

package/test/unit/data-structures/heap/heap.test.ts

@@ -45,14 +45,7 @@ describe('Heap Operation Test', () => {
     maxHeap.add({key: 0, a: 'a0'});
     maxHeap.add({key: 9, a: 'a9'});
     expect(maxHeap.peek()).toEqual({a: 'a9', key: 9});
-    expect(maxHeap.toArray().map(item => ({a: item.a}))).toEqual([
-      {a: 'a9'},
-      {a: 'a2'},
-      {a: 'a6'},
-      {a: 'a1'},
-      {a: 'a0'},
-      {a: 'a5'}
-    ]);
+    expect(maxHeap.toArray().map(item => ({a: item.a}))).toEqual([{a: 'a9'}, {a: 'a2'}, {a: 'a6'}, {a: 'a1'}, {a: 'a0'}, {a: 'a5'}]);
     const maxExpectPolled = [{a: 'a9'}, {a: 'a6'}, {a: 'a5'}, {a: 'a2'}, {a: 'a1'}, {a: 'a0'}];
     let maxI = 0;
     while (maxHeap.size > 0) {