data-structure-typed 1.37.0 → 1.37.2

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

@@ -1,9 +1,9 @@
-import {AVLTree, CP} 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();
@@ -23,22 +23,23 @@ describe('AVL Tree Test', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && tree.subTreeForeach(node15, node => (subTreeSum += node.key));
+    node15 && tree.subTreeTraverse(node => (subTreeSum += node.key), node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    tree.lesserOrGreaterForeach(10, CP.lt, node => (lesserSum += node.key));
+    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);
@@ -97,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,6 +1,6 @@
 import {BST, BSTNode, CP} from '../../../../src';
 
-const isDebug = false;
+const isDebug = true;
 
 describe('BST operations test', () => {
   it('should perform various operations on a Binary Search Tree with numeric values', () => {
@@ -25,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();
@@ -36,11 +36,11 @@ describe('BST operations test', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && bst.subTreeForeach(15, node => (subTreeSum += node.key));
+    node15 && bst.subTreeTraverse(node => (subTreeSum += node.key), 15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    bst.lesserOrGreaterForeach(10, CP.lt, node => (lesserSum += node.key));
+    bst.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.lt, 10);
     expect(lesserSum).toBe(45);
 
     expect(node15).toBeInstanceOf(BSTNode);
@@ -48,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);
 
@@ -173,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);
@@ -222,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();
@@ -237,11 +240,11 @@ describe('BST operations test', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && objBST.subTreeForeach(node15, node => (subTreeSum += node.key));
+    node15 && objBST.subTreeTraverse(node => (subTreeSum += node.key), node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    objBST.lesserOrGreaterForeach(10, CP.lt, node => (lesserSum += node.key));
+    objBST.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.lt, 10);
     expect(lesserSum).toBe(45);
 
     expect(node15).toBeInstanceOf(BSTNode);
@@ -249,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);
 
@@ -374,12 +378,14 @@ 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);
@@ -396,11 +402,11 @@ describe('BST Performance test', function () {
 
   it(`Observe the time consumption of BST.dfs be good`, function () {
     const startDFS = performance.now();
-    const dfs = bst.dfs();
+    const dfs = bst.dfs(node => node);
     isDebug && console.log('---bfs', performance.now() - startDFS, dfs.length);
   });
 
-  it('Should the time consumption of lesserOrGreaterForeach fitting O(n log n)', function () {
+  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);
@@ -409,9 +415,33 @@ describe('BST Performance test', function () {
     bst.addMany(nodes);
     isDebug && console.log('---add', performance.now() - start);
     const startL = performance.now();
-    bst.lesserOrGreaterForeach(inputSize / 2, CP.lt, node => {
-      return node.key - 1;
-    });
-    isDebug && console.log('---lesserOrGreaterForeach', performance.now() - startL);
+    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

@@ -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

@@ -16,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));
 
@@ -25,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);
@@ -41,29 +40,25 @@ describe('TreeMultiset operations test', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && treeMultiset.subTreeForeach(15, (node: TreeMultisetNode<number>) => (subTreeSum += node.key));
+    node15 && treeMultiset.subTreeTraverse((node: TreeMultisetNode<number>) => (subTreeSum += node.key), 15);
     expect(subTreeSum).toBe(70);
     let lesserSum = 0;
-    treeMultiset.lesserOrGreaterForeach(10, CP.lt, (node: TreeMultisetNode<number>) => (lesserSum += node.key));
+    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.subTreeForeach(15, (node: TreeMultisetNode<number>) => (node.count += 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.lesserOrGreaterForeach(
-        11,
-        CP.gt,
-        (node: TreeMultisetNode<number>) => (node.count += 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);
@@ -73,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);
 
@@ -194,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);
@@ -284,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);
     //
@@ -474,18 +469,18 @@ describe('TreeMultiset Performance test', function () {
 
   it(`Observe the time consumption of TreeMultiset.dfs be good`, function () {
     const startDFS = performance.now();
-    const dfs = treeMS.dfs();
+    const dfs = treeMS.dfs(node => node);
     isDebug && console.log('---bfs', performance.now() - startDFS, dfs.length);
   });
 
-  it('Should the time consumption of lesserOrGreaterForeach fitting O(n log n)', function () {
+  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.lesserOrGreaterForeach(inputSize / 2, CP.lt, (node: TreeMultisetNode<number>) => (node.count += 1));
-    isDebug && console.log('---lesserOrGreaterForeach', performance.now() - startL);
+    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);
   });