data-structure-typed 1.49.4 → 1.49.6

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

@@ -9,31 +9,18 @@ suite
   .add(`${HUNDRED_THOUSAND.toLocaleString()} add & poll`, () => {
     const heap = new Heap<number>([], { comparator: (a, b) => b - a });
 
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-      heap.add(i);
-    }
-
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-      heap.poll();
-    }
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) heap.add(i);
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) heap.poll();
   })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} add & dfs`, () => {
     const heap = new Heap<number>([], { comparator: (a, b) => b - a });
-
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-      heap.add(i);
-    }
-
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) heap.add(i);
     heap.dfs();
   })
   .add(`${TEN_THOUSAND.toLocaleString()} fib add & pop`, () => {
     const fbHeap = new FibonacciHeap<number>();
-    for (let i = 1; i <= TEN_THOUSAND; i++) {
-      fbHeap.push(i);
-    }
-    for (let i = 1; i <= TEN_THOUSAND; i++) {
-      fbHeap.pop();
-    }
+    for (let i = 1; i <= TEN_THOUSAND; i++) fbHeap.push(i);
+    for (let i = 1; i <= TEN_THOUSAND; i++) fbHeap.pop();
   });
 
 export { suite };

package/test/performance/data-structures/linked-list/doubly-linked-list.test.ts

@@ -13,7 +13,6 @@ suite.add(`${MILLION.toLocaleString()} push`, () => {
   for (let i = 0; i < MILLION; i++) list.push(i);
 });
 
-
 if (isCompetitor) {
   suite.add(`CPT ${MILLION.toLocaleString()} push`, () => {
     const list = new CLinkedList<number>();
@@ -41,7 +40,6 @@ suite
     const list = new DoublyLinkedList<number>();
 
     for (let i = 0; i < MILLION; i++) list.unshift(i);
-
     for (let i = 0; i < MILLION; i++) list.shift();
   })
   .add(`${MILLION.toLocaleString()} addBefore`, () => {

package/test/performance/data-structures/linked-list/singly-linked-list.test.ts

@@ -10,14 +10,12 @@ suite
     const list = new SinglyLinkedList<number>();
 
     for (let i = 0; i < MILLION; i++) list.push(i);
-
     for (let i = 0; i < MILLION; i++) list.shift();
   })
   .add(`${TEN_THOUSAND.toLocaleString()} push & pop`, () => {
     const list = new SinglyLinkedList<number>();
 
     for (let i = 0; i < TEN_THOUSAND; i++) list.push(i);
-
     for (let i = 0; i < TEN_THOUSAND; i++) list.pop();
   })
   .add(`${TEN_THOUSAND.toLocaleString()} addBefore`, () => {

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

@@ -11,9 +11,7 @@ suite.add(`${TEN_THOUSAND.toLocaleString()} refill & poll`, () => {
   );
   const maxPQ = new MaxPriorityQueue<number>();
   maxPQ.refill(nodes);
-  while (maxPQ.size > 0) {
-    maxPQ.poll();
-  }
+  while (maxPQ.size > 0) maxPQ.poll();
 });
 
-export { suite };
+// export { suite };

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

@@ -10,25 +10,15 @@ const { HUNDRED_THOUSAND } = magnitude;
 suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add & poll`, () => {
   const pq = new PriorityQueue<number>([], { comparator: (a, b) => b - a });
 
-  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-    pq.add(i);
-  }
-
-  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-    pq.poll();
-  }
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) pq.add(i);
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) pq.poll();
 });
 if (isCompetitor) {
   suite.add(`CPT ${HUNDRED_THOUSAND.toLocaleString()} add & pop`, () => {
     const pq = new CPriorityQueue<number>();
 
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-      pq.push(i);
-    }
-
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-      pq.pop();
-    }
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) pq.push(i);
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) pq.pop();
   });
 }
 

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

@@ -19,14 +19,13 @@ if (isCompetitor) {
   });
 }
 
+suite
+  .add(`${MILLION.toLocaleString()} push & pop`, () => {
+    const _deque = new Deque<number>();
 
-suite.add(`${MILLION.toLocaleString()} push & pop`, () => {
-  const _deque = new Deque<number>();
-
-  for (let i = 0; i < MILLION; i++) _deque.push(i);
-  for (let i = 0; i < MILLION; i++) _deque.pop();
-
-})
+    for (let i = 0; i < MILLION; i++) _deque.push(i);
+    for (let i = 0; i < MILLION; i++) _deque.pop();
+  })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} push & shift`, () => {
     const _deque = new Deque<number>();
 

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

@@ -10,49 +10,33 @@ const { MILLION, HUNDRED_THOUSAND } = magnitude;
 suite.add(`${MILLION.toLocaleString()} push`, () => {
   const queue = new Queue<number>();
 
-  for (let i = 0; i < MILLION; i++) {
-    queue.push(i);
-  }
+  for (let i = 0; i < MILLION; i++) queue.push(i);
 });
 if (isCompetitor) {
   suite.add(`CPT ${MILLION.toLocaleString()} push`, () => {
     const queue = new CQueue<number>();
 
-    for (let i = 0; i < MILLION; i++) {
-      queue.push(i);
-    }
+    for (let i = 0; i < MILLION; i++) queue.push(i);
   });
 }
 suite.add(`${HUNDRED_THOUSAND.toLocaleString()} push & shift`, () => {
   const queue = new Queue<number>();
 
-  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-    queue.push(i);
-  }
-  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-    queue.shift();
-  }
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) queue.push(i);
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) queue.shift();
 });
-suite.add(`Native Array ${HUNDRED_THOUSAND.toLocaleString()} push & shift`, () => {
-  const arr = new Array<number>();
-
-  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-    arr.push(i);
-  }
-  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-    arr.shift();
-  }
-})
-  .add(`Native Array ${HUNDRED_THOUSAND.toLocaleString()} push & pop`, () => {
+suite
+  .add(`Native Array ${HUNDRED_THOUSAND.toLocaleString()} push & shift`, () => {
     const arr = new Array<number>();
 
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-      arr.push(i);
-    }
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) arr.push(i);
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) arr.shift();
+  })
+  .add(`Native Array ${HUNDRED_THOUSAND.toLocaleString()} push & pop`, () => {
+    const arr = new Array<number>();
 
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-      arr.pop();
-    }
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) arr.push(i);
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) arr.pop();
   });
 
 export { suite };

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

@@ -10,39 +10,27 @@ const { MILLION } = magnitude;
 suite.add(`${MILLION.toLocaleString()} push`, () => {
   const stack = new Stack<number>();
 
-  for (let i = 0; i < MILLION; i++) {
-    stack.push(i);
-  }
+  for (let i = 0; i < MILLION; i++) stack.push(i);
 });
 if (isCompetitor) {
   suite.add(`CPT ${MILLION.toLocaleString()} push`, () => {
     const queue = new CStack<number>();
 
-    for (let i = 0; i < MILLION; i++) {
-      queue.push(i);
-    }
+    for (let i = 0; i < MILLION; i++) queue.push(i);
   });
 }
 suite.add(`${MILLION.toLocaleString()} push & pop`, () => {
   const queue = new Stack<number>();
 
-  for (let i = 0; i < MILLION; i++) {
-    queue.push(i);
-  }
-  for (let i = 0; i < MILLION; i++) {
-    queue.pop();
-  }
+  for (let i = 0; i < MILLION; i++) queue.push(i);
+  for (let i = 0; i < MILLION; i++) queue.pop();
 });
 if (isCompetitor) {
   suite.add(`CPT ${MILLION.toLocaleString()} push & pop`, () => {
     const queue = new CStack<number>();
 
-    for (let i = 0; i < MILLION; i++) {
-      queue.push(i);
-    }
-    for (let i = 0; i < MILLION; i++) {
-      queue.pop();
-    }
+    for (let i = 0; i < MILLION; i++) queue.push(i);
+    for (let i = 0; i < MILLION; i++) queue.pop();
   });
 }
 

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

@@ -9,14 +9,10 @@ const randomWords = getRandomWords(HUNDRED_THOUSAND, false);
 
 suite
   .add(`${HUNDRED_THOUSAND.toLocaleString()} push`, () => {
-    for (let i = 0; i < randomWords.length; i++) {
-      trie.add(randomWords[i]);
-    }
+    for (let i = 0; i < randomWords.length; i++) trie.add(randomWords[i]);
   })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} getWords`, () => {
-    for (let i = 0; i < randomWords.length; i++) {
-      trie.getWords(randomWords[i]);
-    }
+    for (let i = 0; i < randomWords.length; i++) trie.getWords(randomWords[i]);
   });
 
 export { suite };

package/test/performance/reportor.ts

@@ -5,20 +5,19 @@ import * as fastGlob from 'fast-glob';
 import { Color, numberFix, render } from '../utils';
 import { PerformanceTest } from './types';
 
-
 const args = process.argv.slice(2);
 
 const { GREEN, BOLD, END, YELLOW, GRAY, CYAN, BG_YELLOW } = Color;
 
 const getRelativePath = (file: string) => {
   return path.relative(__dirname, file);
-}
+};
 const coloredLabeled = (label: string, file: string) => {
   const relativeFilePath = getRelativePath(file);
   const directory = path.dirname(relativeFilePath);
   const fileName = path.basename(relativeFilePath);
   return `${BG_YELLOW} ${label} ${END} ${GRAY}${directory}/${END}${CYAN}${fileName}${END}`;
-}
+};
 
 const parentDirectory = path.resolve(__dirname, '../..');
 const reportDistPath = path.join(parentDirectory, 'benchmark');
@@ -29,20 +28,19 @@ let testFiles: string[];
 
 let isIndividual = false;
 if (args.length > 0) {
-  console.log(`arguments: ${args.join(' ')}`)
+  console.log(`arguments: ${args.join(' ')}`);
 
-  testFiles = allFiles.filter(file =>
-    args.every(word => file.includes(word))
-  );
+  testFiles = allFiles.filter(file => args.every(word => file.includes(word)));
   isIndividual = true;
-  console.log(`${testFiles.map(file => coloredLabeled('Matched', file)).join(`
-`)}`);
+  console.log(
+    `${testFiles.map(file => coloredLabeled('Matched', file)).join(`
+`)}`
+  );
 } else {
   isIndividual = false;
   testFiles = allFiles;
 }
 
-
 const report: { [key: string]: any } = {};
 
 let completedCount = 0;
@@ -132,11 +130,12 @@ const composeReport = () => {
   html += `</div>
                     </body>
                   </html>`;
-  if (!isIndividual) replaceMarkdownContent(
-    '[//]: # (No deletion!!! Start of Replace Section)', // Start tag
-    '[//]: # (No deletion!!! End of Replace Section)', // end identifier
-    htmlTables // New content to be inserted
-  );
+  if (!isIndividual)
+    replaceMarkdownContent(
+      '[//]: # (No deletion!!! Start of Replace Section)', // Start tag
+      '[//]: # (No deletion!!! End of Replace Section)', // end identifier
+      htmlTables // New content to be inserted
+    );
   fs.writeFileSync(htmlFilePath, html);
   console.log(`Performance ${BOLD}${GREEN}report${END} file generated in file://${BOLD}${GREEN}${htmlFilePath}${END}`);
 };

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

@@ -318,13 +318,20 @@ describe('AVLTree iterative methods test', () => {
   test('filter should return a new tree with filtered elements', () => {
     const filteredTree = avl.filter((value, key) => key > 1);
     expect(filteredTree.size).toBe(2);
-    expect([...filteredTree]).toEqual([[2, 'b'], [3, 'c']]);
+    expect([...filteredTree]).toEqual([
+      [2, 'b'],
+      [3, 'c']
+    ]);
   });
 
   test('map should return a new tree with modified elements', () => {
     const mappedTree = avl.map((value, key) => (key * 2).toString());
     expect(mappedTree.size).toBe(3);
-    expect([...mappedTree]).toEqual([[1, '2'], [2, '4'], [3, '6']]);
+    expect([...mappedTree]).toEqual([
+      [1, '2'],
+      [2, '4'],
+      [3, '6']
+    ]);
   });
 
   test('reduce should accumulate values', () => {
@@ -339,7 +346,11 @@ describe('AVLTree iterative methods test', () => {
     }
 
     expect(entries.length).toBe(3);
-    expect(entries).toEqual([[1, 'a'], [2, 'b'], [3, 'c']]);
+    expect(entries).toEqual([
+      [1, 'a'],
+      [2, 'b'],
+      [3, 'c']
+    ]);
   });
 
   test('should clone work well', () => {

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

@@ -106,7 +106,8 @@ describe('BinaryTree', () => {
   it('should delete nodes', () => {
     expect(tree.getHeight(tree.root, IterationType.ITERATIVE)).toBe(-1);
     expect(tree.getMinHeight()).toBe(-1);
-    const node1 = tree.add(1);
+    const node1 = tree.createNode(1);
+    tree.add(node1);
     expect(tree.size).toBe(1);
 
     const leftChild = new BinaryTreeNode<number>(2);
@@ -224,15 +225,15 @@ describe('BinaryTree', () => {
       new BinaryTreeNode(4, 4)
     ]);
 
-    expect(tree.isSubtreeBST(tree.getNode(4), IterationType.RECURSIVE)).toBe(true);
-    expect(tree.isSubtreeBST(tree.getNode(4), IterationType.ITERATIVE)).toBe(true);
+    expect(tree.isBST(tree.getNode(4), IterationType.RECURSIVE)).toBe(true);
+    expect(tree.isBST(tree.getNode(4), IterationType.ITERATIVE)).toBe(true);
   });
 
   it('should isSubtreeBST', () => {
     tree.addMany([4, 2, 6, 1, 3, 5, 7, 4]);
 
-    expect(tree.isSubtreeBST(tree.getNode(4), IterationType.RECURSIVE)).toBe(true);
-    expect(tree.isSubtreeBST(tree.getNode(4), IterationType.ITERATIVE)).toBe(true);
+    expect(tree.isBST(tree.getNode(4), IterationType.RECURSIVE)).toBe(true);
+    expect(tree.isBST(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)]);
   });
@@ -265,7 +266,22 @@ describe('BinaryTree', () => {
     tree.clear();
     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([-10, 9, 20, null, null, 15, 7, 8, null, 2, null, 6, null, null])
+    expect(tree.bfs(node => (node ? node.key : null), undefined, undefined, true)).toEqual([
+      -10,
+      9,
+      20,
+      null,
+      null,
+      15,
+      7,
+      8,
+      null,
+      2,
+      null,
+      6,
+      null,
+      null
+    ]);
   });
 });
 
@@ -525,18 +541,12 @@ describe('BinaryTree', () => {
     tree.add([3, 'B']);
     tree.add([7, 'C']);
 
-    const nodes = tree.getNodes('B', (node) => node.value);
+    const nodes = tree.getNodes('B', node => node.value);
 
     expect(nodes.length).toBe(1);
     expect(nodes[0].key).toBe(3);
 
-    const nodesRec = tree.getNodes(
-      'B',
-      (node) => node.value,
-      false,
-      tree.root,
-      IterationType.RECURSIVE
-    );
+    const nodesRec = tree.getNodes('B', node => node.value, false, tree.root, IterationType.RECURSIVE);
 
     expect(nodesRec.length).toBe(1);
     expect(nodesRec[0].key).toBe(3);
@@ -548,9 +558,17 @@ describe('BinaryTree', () => {
     tree.add([7, 'C']);
 
     tree.iterationType = IterationType.ITERATIVE;
-    expect([...tree]).toEqual([[3, "B"], [5, "A"], [7, "C"]]);
+    expect([...tree]).toEqual([
+      [3, 'B'],
+      [5, 'A'],
+      [7, 'C']
+    ]);
     tree.iterationType = IterationType.RECURSIVE;
-    expect([...tree]).toEqual([[3, "B"], [5, "A"], [7, "C"]]);
+    expect([...tree]).toEqual([
+      [3, 'B'],
+      [5, 'A'],
+      [7, 'C']
+    ]);
     tree.iterationType = IterationType.ITERATIVE;
 
     const result = tree.morris();
@@ -600,13 +618,20 @@ describe('BinaryTree iterative methods test', () => {
   test('filter should return a new tree with filtered elements', () => {
     const filteredTree = binaryTree.filter((value, key) => key > 1);
     expect(filteredTree.size).toBe(2);
-    expect([...filteredTree]).toEqual([[3, 'c'], [2, 'b']]);
+    expect([...filteredTree]).toEqual([
+      [3, 'c'],
+      [2, 'b']
+    ]);
   });
 
   test('map should return a new tree with modified elements', () => {
     const mappedTree = binaryTree.map((value, key) => (key * 2).toString());
     expect(mappedTree.size).toBe(3);
-    expect([...mappedTree]).toEqual([[1, '2'], [2, '4'], [3, '6']]);
+    expect([...mappedTree]).toEqual([
+      [1, '2'],
+      [2, '4'],
+      [3, '6']
+    ]);
   });
 
   test('reduce should accumulate values', () => {
@@ -621,7 +646,11 @@ describe('BinaryTree iterative methods test', () => {
     }
 
     expect(entries.length).toBe(3);
-    expect(entries).toEqual([[2, 'b'], [1, 'a'], [3, 'c']]);
+    expect(entries).toEqual([
+      [2, 'b'],
+      [1, 'a'],
+      [3, 'c']
+    ]);
   });
 
   test('should clone work well', () => {
@@ -641,17 +670,24 @@ describe('BinaryTree iterative methods test', () => {
   });
 
   test('should iterative method return undefined when the node is null', () => {
-    const tree = new BinaryTree()
+    const tree = new BinaryTree();
     tree.addMany([-10, -10, -10, 9, 9, 20, null, null, 15, 7, 8, null, 2, null, 6, null, null, 8, 8, 8]);
     const bfsResult = tree.bfs(undefined, undefined, undefined, true);
     expect(bfsResult).toEqual([
-      -10, 9,
-      20, undefined,
-      undefined, 15,
-      7, 8,
-      undefined, 2,
-      undefined, 6,
-      undefined, undefined
+      -10,
+      9,
+      20,
+      undefined,
+      undefined,
+      15,
+      7,
+      8,
+      undefined,
+      2,
+      undefined,
+      6,
+      undefined,
+      undefined
     ]);
-  })
-});
+  });
+});