data-structure-typed 1.36.9 → 1.37.1

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

@@ -1,9 +1,9 @@
-import {AVLTree} from '../../../../src';
+import {AVLTree, CP, AVLTreeNode} from '../../../../src';
 
 describe('AVL Tree Test', () => {
   it('should perform various operations on a AVL Tree', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-    const tree = new AVLTree();
+    const tree = new AVLTree<AVLTreeNode<number>>();
 
     for (const i of arr) tree.add(i, i);
 
@@ -12,7 +12,7 @@ describe('AVL Tree Test', () => {
     expect(node6 && tree.getHeight(node6)).toBe(3);
     expect(node6 && tree.getDepth(node6)).toBe(1);
 
-    const getNodeById = tree.get(10, 'key');
+    const getNodeById = tree.get(10);
     expect(getNodeById?.key).toBe(10);
 
     const getMinNodeByRoot = tree.getLeftMost();
@@ -22,21 +22,24 @@ describe('AVL Tree Test', () => {
     const getMinNodeBySpecificNode = node15 && tree.getLeftMost(node15);
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
-    const subTreeSum = node15 && tree.subTreeSum(node15);
+    let subTreeSum = 0;
+    node15 && tree.subTreeTraverse(node => (subTreeSum += node.key), node15);
     expect(subTreeSum).toBe(70);
 
-    const lesserSum = tree.lesserSum(10);
+    let lesserSum = 0;
+    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.lt, 10);
     expect(lesserSum).toBe(45);
 
     // node15 has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.
     expect(node15?.val).toBe(15);
 
-    const dfs = tree.dfs('in', 'node');
+    const dfs = tree.dfs(node => node, 'in');
     expect(dfs[0].key).toBe(1);
     expect(dfs[dfs.length - 1].key).toBe(16);
 
     tree.perfectlyBalance();
-    const bfs = tree.bfs('node');
+    const bfs: AVLTreeNode<number>[] = [];
+    tree.bfs(node => bfs.push(node));
     expect(tree.isPerfectlyBalanced()).toBe(true);
     expect(bfs[0].key).toBe(8);
     expect(bfs[bfs.length - 1].key).toBe(16);
@@ -95,12 +98,14 @@ describe('AVL Tree Test', () => {
     expect(tree.getHeight()).toBe(1);
 
     expect(tree.isAVLBalanced()).toBe(true);
-    const lastBFSIds = tree.bfs();
+    const lastBFSIds = new Array<number>();
+    tree.bfs(node => lastBFSIds.push(node.key));
     expect(lastBFSIds[0]).toBe(12);
     expect(lastBFSIds[1]).toBe(2);
     expect(lastBFSIds[2]).toBe(16);
 
-    const lastBFSNodes = tree.bfs('node');
+    const lastBFSNodes: AVLTreeNode<number>[] = [];
+    tree.bfs(node => lastBFSNodes.push(node));
     expect(lastBFSNodes[0].key).toBe(12);
     expect(lastBFSNodes[1].key).toBe(2);
     expect(lastBFSNodes[2].key).toBe(16);

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

@@ -127,7 +127,7 @@ describe('BinaryTree', () => {
     binaryTree.add(5);
     binaryTree.add(7);
 
-    const inOrder = binaryTree.dfs('in');
+    const inOrder = binaryTree.dfs(node => node.key);
 
     expect(inOrder).toEqual([1, 2, 3, 4, 5, 6, 7]);
   });

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

@@ -1,4 +1,6 @@
-import {BST, BSTNode} from '../../../../src';
+import {BST, BSTNode, CP} from '../../../../src';
+
+const isDebug = true;
 
 describe('BST operations test', () => {
   it('should perform various operations on a Binary Search Tree with numeric values', () => {
@@ -7,7 +9,7 @@ describe('BST operations test', () => {
     bst.add(11, 11);
     bst.add(3, 3);
     const idsAndValues = [15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-    bst.addMany(idsAndValues, idsAndValues);
+    bst.addMany(idsAndValues, idsAndValues, false);
     expect(bst.root).toBeInstanceOf(BSTNode);
 
     if (bst.root) expect(bst.root.key).toBe(11);
@@ -23,7 +25,7 @@ describe('BST operations test', () => {
     const nodeId10 = bst.get(10);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = bst.get(9, 'val');
+    const nodeVal9 = bst.get(9, node => node.val);
     expect(nodeVal9?.key).toBe(9);
 
     const leftMost = bst.getLeftMost();
@@ -33,10 +35,12 @@ describe('BST operations test', () => {
     const minNodeBySpecificNode = node15 && bst.getLeftMost(node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
 
-    const subTreeSum = node15 && bst.subTreeSum(15);
+    let subTreeSum = 0;
+    node15 && bst.subTreeTraverse(node => (subTreeSum += node.key), 15);
     expect(subTreeSum).toBe(70);
 
-    const lesserSum = bst.lesserSum(10);
+    let lesserSum = 0;
+    bst.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.lt, 10);
     expect(lesserSum).toBe(45);
 
     expect(node15).toBeInstanceOf(BSTNode);
@@ -44,14 +48,15 @@ describe('BST operations test', () => {
     const node11 = bst.get(11);
     expect(node11).toBeInstanceOf(BSTNode);
 
-    const dfsInorderNodes = bst.dfs('in', 'node');
+    const dfsInorderNodes = bst.dfs(node => node, 'in');
     expect(dfsInorderNodes[0].key).toBe(1);
     expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
 
     bst.perfectlyBalance();
     expect(bst.isPerfectlyBalanced()).toBe(true);
 
-    const bfsNodesAfterBalanced = bst.bfs('node');
+    const bfsNodesAfterBalanced: BSTNode<number>[] = [];
+    bst.bfs(node => bfsNodesAfterBalanced.push(node));
     expect(bfsNodesAfterBalanced[0].key).toBe(8);
     expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
 
@@ -169,12 +174,14 @@ describe('BST operations test', () => {
 
     expect(bst.isAVLBalanced()).toBe(false);
 
-    const bfsIDs = bst.bfs();
+    const bfsIDs: number[] = [];
+    bst.bfs(node => bfsIDs.push(node.key));
     expect(bfsIDs[0]).toBe(2);
     expect(bfsIDs[1]).toBe(12);
     expect(bfsIDs[2]).toBe(16);
 
-    const bfsNodes = bst.bfs('node');
+    const bfsNodes: BSTNode<number>[] = [];
+    bst.bfs(node => bfsNodes.push(node));
     expect(bfsNodes[0].key).toBe(2);
     expect(bfsNodes[1].key).toBe(12);
     expect(bfsNodes[2].key).toBe(16);
@@ -204,7 +211,8 @@ describe('BST operations test', () => {
 
     objBST.addMany(
       values.map(item => item.key),
-      values
+      values,
+      false
     );
 
     expect(objBST.root).toBeInstanceOf(BSTNode);
@@ -217,10 +225,10 @@ describe('BST operations test', () => {
     expect(node6 && objBST.getHeight(node6)).toBe(2);
     expect(node6 && objBST.getDepth(node6)).toBe(3);
 
-    const nodeId10 = objBST.get(10, 'key');
+    const nodeId10 = objBST.get(10);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = objBST.get(9, 'key');
+    const nodeVal9 = objBST.get(9);
     expect(nodeVal9?.key).toBe(9);
 
     const leftMost = objBST.getLeftMost();
@@ -231,10 +239,12 @@ describe('BST operations test', () => {
     const minNodeBySpecificNode = node15 && objBST.getLeftMost(node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
 
-    const subTreeSum = node15 && objBST.subTreeSum(node15);
+    let subTreeSum = 0;
+    node15 && objBST.subTreeTraverse(node => (subTreeSum += node.key), node15);
     expect(subTreeSum).toBe(70);
 
-    const lesserSum = objBST.lesserSum(10);
+    let lesserSum = 0;
+    objBST.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.lt, 10);
     expect(lesserSum).toBe(45);
 
     expect(node15).toBeInstanceOf(BSTNode);
@@ -242,14 +252,15 @@ describe('BST operations test', () => {
     const node11 = objBST.get(11);
     expect(node11).toBeInstanceOf(BSTNode);
 
-    const dfsInorderNodes = objBST.dfs('in', 'node');
+    const dfsInorderNodes = objBST.dfs(node => node, 'in');
     expect(dfsInorderNodes[0].key).toBe(1);
     expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
 
     objBST.perfectlyBalance();
     expect(objBST.isPerfectlyBalanced()).toBe(true);
 
-    const bfsNodesAfterBalanced = objBST.bfs('node');
+    const bfsNodesAfterBalanced: BSTNode<{key: number; keyA: number}>[] = [];
+    objBST.bfs(node => bfsNodesAfterBalanced.push(node));
     expect(bfsNodesAfterBalanced[0].key).toBe(8);
     expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
 
@@ -367,14 +378,70 @@ describe('BST operations test', () => {
 
     expect(objBST.isAVLBalanced()).toBe(false);
 
-    const bfsIDs = objBST.bfs();
+    const bfsIDs: number[] = [];
+    objBST.bfs(node => bfsIDs.push(node.key));
     expect(bfsIDs[0]).toBe(2);
     expect(bfsIDs[1]).toBe(12);
     expect(bfsIDs[2]).toBe(16);
 
-    const bfsNodes = objBST.bfs('node');
+    const bfsNodes: BSTNode<{key: number; keyA: number}>[] = [];
+    objBST.bfs(node => bfsNodes.push(node));
     expect(bfsNodes[0].key).toBe(2);
     expect(bfsNodes[1].key).toBe(12);
     expect(bfsNodes[2].key).toBe(16);
   });
 });
+
+describe('BST Performance test', function () {
+  const bst = new BST<BSTNode<number>>();
+  const inputSize = 10000; // Adjust input sizes as needed
+
+  beforeEach(() => {
+    bst.clear();
+  });
+
+  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);
+  });
+
+  it('Should the time consumption of lesserOrGreaterTraverse fitting O(n log n)', function () {
+    const nodes: number[] = [];
+    for (let i = 0; i < inputSize; i++) {
+      nodes.push(i);
+    }
+    const start = performance.now();
+    bst.addMany(nodes);
+    isDebug && console.log('---add', performance.now() - start);
+    const startL = performance.now();
+    bst.lesserOrGreaterTraverse(
+      node => {
+        node.key - 1;
+      },
+      CP.lt,
+      inputSize / 2
+    );
+    isDebug && console.log('---lesserOrGreaterTraverse', performance.now() - startL);
+  });
+
+  it('Should the time consumption of listLevels fitting well', function () {
+    const nodes: number[] = [];
+    for (let i = 0; i < inputSize; i++) {
+      nodes.push(i);
+    }
+    const start = performance.now();
+    bst.addMany(nodes);
+    isDebug && console.log('---add', performance.now() - start);
+    const startL = performance.now();
+    const arr: number[][] = [];
+    bst.bfs((node, level) => {
+      if (level !== undefined) {
+        if (!arr[level]) arr[level] = [];
+        arr[level].push(node.key);
+      }
+    }, true);
+    isDebug && console.log('---listLevels', arr);
+    isDebug && console.log('---listLevels', performance.now() - startL);
+  });
+});

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

@@ -5,7 +5,7 @@ describe('Overall BinaryTree Test', () => {
     const bst = new BST();
     bst.add(11);
     bst.add(3);
-    bst.addMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5]);
+    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
@@ -24,7 +24,8 @@ describe('Overall BinaryTree Test', () => {
     expect(bst.get(6)).toBeNull();
     bst.isAVLBalanced(); // true or false
     expect(bst.isAVLBalanced()).toBe(true);
-    const bfsIDs = bst.bfs();
+    const bfsIDs: number[] = [];
+    bst.bfs(node => bfsIDs.push(node.key));
     bfsIDs[0] === 11; // true
     expect(bfsIDs[0]).toBe(11);
 

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

@@ -7,7 +7,7 @@ describe('Red-Black Tree Tests', () => {
   //   tree = new RBTree<RBTreeNode<number>>();
   // });
 
-  test('Insertion and In-order Traversal', () => {
+  test('Insertion and In-order Traverse', () => {
     // tree.add(5);
     // tree.add(3);
     // tree.add(7);
@@ -16,9 +16,9 @@ describe('Red-Black Tree Tests', () => {
     // tree.add(6);
     // tree.add(8);
     //
-    // const inOrderTraversal: number[] = tree.DFS('in')
+    // const inOrderTraverse: number[] = tree.DFS('in')
     //
-    // expect(inOrderTraversal).toEqual([2, 3, 4, 5, 6, 7, 8]);
+    // expect(inOrderTraverse).toEqual([2, 3, 4, 5, 6, 7, 8]);
   });
 
   test('Deletion', () => {
@@ -35,9 +35,9 @@ describe('Red-Black Tree Tests', () => {
     // expect(tree.has(3)).toBe(false);
     //
     // // Perform in-order traversal to check if the tree is still balanced
-    // const inOrderTraversal: number[] = tree.DFS('in');
+    // const inOrderTraverse: number[] = tree.DFS('in');
     //
     //
-    // expect(inOrderTraversal).toEqual([2, 4, 5, 6, 7, 8]);
+    // expect(inOrderTraverse).toEqual([2, 4, 5, 6, 7, 8]);
   });
 });

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

@@ -1,5 +1,6 @@
-import {TreeMultiset, TreeMultisetNode} from '../../../../src';
+import {CP, TreeMultiset, TreeMultisetNode} from '../../../../src';
 
+const isDebug = false;
 describe('TreeMultiset operations test', () => {
   it('should perform various operations on a Binary Search Tree with numeric values', () => {
     const treeMultiset = new TreeMultiset();
@@ -15,7 +16,6 @@ describe('TreeMultiset operations test', () => {
 
     expect(treeMultiset.size).toBe(16);
     expect(treeMultiset.count).toBe(18);
-    expect(treeMultiset.bfs('key'));
 
     expect(treeMultiset.has(6));
 
@@ -24,13 +24,13 @@ describe('TreeMultiset operations test', () => {
     const nodeId10 = treeMultiset.get(10);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = treeMultiset.get(9, 'val');
+    const nodeVal9 = treeMultiset.get(9, node => node.val);
     expect(nodeVal9?.key).toBe(9);
 
-    const nodesByCount1 = treeMultiset.getNodesByCount(1);
+    const nodesByCount1 = treeMultiset.getNodes(1, node => node.count);
     expect(nodesByCount1.length).toBe(14);
 
-    const nodesByCount2 = treeMultiset.getNodesByCount(2);
+    const nodesByCount2 = treeMultiset.getNodes(2, node => node.count);
     expect(nodesByCount2.length).toBe(2);
     const leftMost = treeMultiset.getLeftMost();
     expect(leftMost?.key).toBe(1);
@@ -39,24 +39,26 @@ describe('TreeMultiset operations test', () => {
     const minNodeBySpecificNode = node15 && treeMultiset.getLeftMost(node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
 
-    const subTreeSum = node15 && treeMultiset.subTreeSum(15);
+    let subTreeSum = 0;
+    node15 && treeMultiset.subTreeTraverse((node: TreeMultisetNode<number>) => (subTreeSum += node.key), 15);
     expect(subTreeSum).toBe(70);
-    const lesserSum = treeMultiset.lesserSum(10);
+    let lesserSum = 0;
+    treeMultiset.lesserOrGreaterTraverse((node: TreeMultisetNode<number>) => (lesserSum += node.key), CP.lt, 10);
     expect(lesserSum).toBe(45);
 
     expect(node15 instanceof TreeMultisetNode);
     if (node15 instanceof TreeMultisetNode) {
-      const subTreeAdd = treeMultiset.subTreeAddCount(15, 1);
+      const subTreeAdd = treeMultiset.subTreeTraverse((node: TreeMultisetNode<number>) => (node.count += 1), 15);
       expect(subTreeAdd);
     }
     const node11 = treeMultiset.get(11);
     expect(node11 instanceof TreeMultisetNode);
     if (node11 instanceof TreeMultisetNode) {
-      const allGreaterNodesAdded = treeMultiset.allGreaterNodesAddCount(11, 2);
+      const allGreaterNodesAdded = treeMultiset.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 11);
       expect(allGreaterNodesAdded);
     }
 
-    const dfsInorderNodes = treeMultiset.dfs('in', 'node');
+    const dfsInorderNodes = treeMultiset.dfs(node => node, 'in');
     expect(dfsInorderNodes[0].key).toBe(1);
     expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
     expect(treeMultiset.isPerfectlyBalanced()).toBe(false);
@@ -66,7 +68,7 @@ describe('TreeMultiset operations test', () => {
     expect(treeMultiset.isPerfectlyBalanced()).toBe(true);
     expect(treeMultiset.isAVLBalanced()).toBe(true);
 
-    const bfsNodesAfterBalanced = treeMultiset.bfs('node');
+    const bfsNodesAfterBalanced = treeMultiset.bfs(node => node);
     expect(bfsNodesAfterBalanced[0].key).toBe(8);
     expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
 
@@ -187,13 +189,13 @@ describe('TreeMultiset operations test', () => {
 
     expect(treeMultiset.isAVLBalanced()).toBe(true);
 
-    const bfsIDs = treeMultiset.bfs();
+    const bfsIDs = treeMultiset.bfs(node => node.key);
 
     expect(bfsIDs[0]).toBe(12);
     expect(bfsIDs[1]).toBe(2);
     expect(bfsIDs[2]).toBe(16);
 
-    const bfsNodes = treeMultiset.bfs('node');
+    const bfsNodes = treeMultiset.bfs(node => node);
 
     expect(bfsNodes[0].key).toBe(12);
     expect(bfsNodes[1].key).toBe(2);
@@ -277,7 +279,7 @@ describe('TreeMultiset operations test', () => {
     //     expect(allGreaterNodesAdded).toBeDefined();
     // }
     //
-    // const dfsInorderNodes = objTreeMultiset.dfs('in', 'node');
+    // const dfsInorderNodes = objTreeMultiset.dfs(node => node, 'in');
     // expect(dfsInorderNodes[0].key).toBe(1);
     // expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
     //
@@ -419,13 +421,19 @@ describe('TreeMultiset operations test', () => {
 
 describe('TreeMultiset Performance test', function () {
   // const treeMS = new TreeMultiset<TreeMultisetNode<number>>();
-  // const inputSizes = [100]; // Adjust input sizes as needed
+  // const inputSize = [100]; // Adjust input sizes as needed
   //
   // // Define a function to calculate the expected O(n log n) time
   // function expectedTime(n: number): number {
   //   return n * Math.log(n);
   // }
 
+  const treeMS = new TreeMultiset<TreeMultisetNode<number>>();
+  const inputSize = 100000; // Adjust input sizes as needed
+
+  beforeEach(() => {
+    treeMS.clear();
+  });
   it(`Observe the time consumption of TreeMultiset.add fitting O(n log n)`, function () {
     // // Create a benchmark suite
     // const suite = new Benchmark.Suite();
@@ -437,9 +445,9 @@ describe('TreeMultiset Performance test', function () {
     //   }
     //   return arr;
     // }
-    // const inputArray = generateRandomArray(inputSizes[0]);
+    // const inputArray = generateRandomArray(inputSize[0]);
     //
-    // suite.add(`TreeMultiset addMany (n=${inputSizes[0]})`, () => {
+    // suite.add(`TreeMultiset addMany (n=${inputSize[0]})`, () => {
     //   treeMS.addMany([...inputArray]);
     // });
     //
@@ -453,9 +461,26 @@ describe('TreeMultiset Performance test', function () {
     //     console.log(`Input size (n): ${n}, Observed time: ${observedTime.toFixed(2)}ms, Expected time: ${expected.toFixed(2)}ms`);
     //   })
     //   .on('complete', () => {
-    //     console.log(`Benchmark (n=${inputSizes[0]}) completed.`);
+    //     console.log(`Benchmark (n=${inputSize[0]}) completed.`);
     //     done(); // Call done to indicate the test is complete
     //   })
     //   .run({async: true});
   });
+
+  it(`Observe the time consumption of TreeMultiset.dfs be good`, function () {
+    const startDFS = performance.now();
+    const dfs = treeMS.dfs(node => node);
+    isDebug && console.log('---bfs', performance.now() - startDFS, dfs.length);
+  });
+
+  it('Should the time consumption of lesserOrGreaterTraverse fitting O(n log n)', function () {
+    const start = performance.now();
+    for (let i = 0; i < inputSize; i++) {
+      treeMS.add(i);
+    }
+    isDebug && console.log('---add', performance.now() - start);
+    const startL = performance.now();
+    treeMS.lesserOrGreaterTraverse((node: TreeMultisetNode<number>) => (node.count += 1), CP.lt, inputSize / 2);
+    isDebug && console.log('---lesserOrGreaterTraverse', performance.now() - startL);
+  });
 });

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

@@ -90,7 +90,7 @@ describe('MaxPriorityQueue Performance Test', () => {
       }
     }
     const cost = performance.now() - startTime;
-    expect(cost).toBeLessThan(bigO.LINEAR * 20);
+    expect(cost).toBeLessThan(bigO.LINEAR * 30);
     expect(prev).toBeGreaterThan(0);
   });
 

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

@@ -1,4 +1,5 @@
 import {Deque, ArrayDeque, ObjectDeque} from '../../../../src';
+import {bigO} from '../../../utils';
 
 describe('Deque Tests', () => {
   // Test cases for the Deque class (DoublyLinkedList-based)
@@ -128,3 +129,19 @@ describe('Deque Tests', () => {
     // Add more test cases as needed
   });
 });
+
+describe('Deque Performance Test', () => {
+  const dataSize = 10000;
+  it('should numeric queue be efficient', function () {
+    const startTime = performance.now();
+    const queue = new Deque<number>();
+    for (let i = 0; i < dataSize; i++) {
+      queue.unshift(i);
+    }
+    for (let i = 0; i < dataSize; i++) {
+      queue.pop();
+    }
+    console.log(`Queue Deque Test: ${performance.now() - startTime} ms`);
+    expect(performance.now() - startTime).toBeLessThan(bigO.LINEAR * 100);
+  });
+});

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

@@ -197,3 +197,45 @@ describe('LinkedListQueue', () => {
 
   // Add more test cases for other methods of LinkedListQueue.
 });
+
+describe('Queue Performance Test', () => {
+  const dataSize = 10000;
+  it('should numeric queue be efficient', function () {
+    const startTime = performance.now();
+    const queue = new Queue<number>();
+    for (let i = 0; i < dataSize; i++) {
+      queue.enqueue(i);
+    }
+    for (let i = 0; i < dataSize; i++) {
+      queue.dequeue();
+    }
+    console.log(`Queue Performance Test: ${performance.now() - startTime} ms`);
+    expect(performance.now() - startTime).toBeLessThan(bigO.LINEAR * 100);
+  });
+
+  it('should numeric Array be more efficient than Queue when the data size is 10000', function () {
+    const startTime2 = performance.now();
+    const queue2: number[] = [];
+    for (let i = 0; i < dataSize; i++) {
+      queue2.push(i);
+    }
+    for (let i = 0; i < dataSize; i++) {
+      queue2.shift();
+    }
+    console.log(`Array Performance Test: ${performance.now() - startTime2} ms`);
+    expect(performance.now() - startTime2).toBeLessThan(bigO.CUBED * 100);
+  });
+
+  it('should numeric LinkedListQueue be efficient', function () {
+    const startTime = performance.now();
+    const queue = new LinkedListQueue<number>();
+    for (let i = 0; i < dataSize; i++) {
+      queue.enqueue(i);
+    }
+    for (let i = 0; i < dataSize; i++) {
+      queue.dequeue();
+    }
+    console.log(`LinkedListQueue Performance Test: ${performance.now() - startTime} ms`);
+    expect(performance.now() - startTime).toBeLessThan(bigO.LINEAR * 100);
+  });
+});

package/test/utils/big-o.ts

@@ -1,5 +1,6 @@
 import {AnyFunction} from '../types';
 
+const isDebug = false;
 const orderReducedBy = 2; // reduction of bigO's order compared to the baseline bigO
 
 export const magnitude = {
@@ -148,12 +149,12 @@ export function logBigOMetricsWrap<F extends AnyFunction>(fn: F, args: Parameter
     methodLog.push([runTime, maxDataSize]);
 
     if (methodLog.length >= 20) {
-      console.log('triggered', methodName, methodLog);
+      isDebug && console.log('triggered', methodName, methodLog);
       const bigO = estimateBigO(
         methodLog.map(([runTime]) => runTime),
         methodLog.map(([runTime]) => runTime)
       );
-      console.log(`Estimated Big O: ${bigO}`);
+      isDebug && console.log(`Estimated Big O: ${bigO}`);
       methodLogs.delete(methodName);
     }
   }
@@ -182,12 +183,12 @@ export function logBigOMetrics(target: any, propertyKey: string, descriptor: Pro
       methodLog.push([runTime, maxDataSize]);
 
       if (methodLog.length >= 20) {
-        console.log('triggered', methodName, methodLog);
+        isDebug && console.log('triggered', methodName, methodLog);
         const bigO = estimateBigO(
           methodLog.map(([runTime]) => runTime),
           methodLog.map(([runTime]) => runTime)
         );
-        console.log(`Estimated Big O: ${bigO}`);
+        isDebug && console.log(`Estimated Big O: ${bigO}`);
         methodLogs.delete(methodName);
       }
     }