data-structure-typed 1.51.7 → 1.51.9

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

@@ -28,7 +28,7 @@ describe('AVLTreeMultiMap count', () => {
       [3, 3]
     ]);
     tm.add([2, 2], undefined, 10);
-    tm.lesserOrGreaterTraverse(node => (node.count += 2), 'GT', 1);
+    tm.lesserOrGreaterTraverse(node => (node.count += 2), 1, 1);
     tm.delete(2);
     expect(tm.count).toBe(12);
     expect(tm.getComputedCount()).toBe(16);
@@ -37,7 +37,7 @@ describe('AVLTreeMultiMap count', () => {
 
 describe('AVLTreeMultiMap operations test1', () => {
   it('should perform various operations on a Binary Search Tree with numeric values1', () => {
-    const treeMultimap = new AVLTreeMultiMap();
+    const treeMultimap = new AVLTreeMultiMap<number>();
 
     expect(treeMultimap instanceof AVLTreeMultiMap);
     treeMultimap.add([11, 11]);
@@ -94,7 +94,7 @@ describe('AVLTreeMultiMap operations test1', () => {
     node15 && treeMultimap.dfs(node => (subTreeSum += node.key), 'PRE', 15);
     expect(subTreeSum).toBe(31);
     let lesserSum = 0;
-    treeMultimap.lesserOrGreaterTraverse((node: AVLTreeMultiMapNode<number>) => (lesserSum += node.key), 'LT', 10);
+    treeMultimap.lesserOrGreaterTraverse((node: AVLTreeMultiMapNode<number>) => (lesserSum += node.key), -1, 10);
     expect(lesserSum).toBe(45);
 
     expect(node15 instanceof AVLTreeMultiMapNode);
@@ -105,7 +105,7 @@ describe('AVLTreeMultiMap operations test1', () => {
     const node11 = treeMultimap.getNode(11);
     expect(node11 instanceof AVLTreeMultiMapNode);
     if (node11 instanceof AVLTreeMultiMapNode) {
-      const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), 'GT', 11);
+      const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), 1, 11);
       expect(allGreaterNodesAdded);
     }
 
@@ -348,7 +348,7 @@ describe('AVLTreeMultiMap operations test recursively1', () => {
     node15 && treeMultimap.dfs(node => (subTreeSum += node.key), 'PRE', 15);
     expect(subTreeSum).toBe(31);
     let lesserSum = 0;
-    treeMultimap.lesserOrGreaterTraverse((node: AVLTreeMultiMapNode<number>) => (lesserSum += node.key), 'LT', 10);
+    treeMultimap.lesserOrGreaterTraverse((node: AVLTreeMultiMapNode<number>) => (lesserSum += node.key), -1, 10);
     expect(lesserSum).toBe(45);
 
     expect(node15 instanceof AVLTreeMultiMapNode);
@@ -359,7 +359,7 @@ describe('AVLTreeMultiMap operations test recursively1', () => {
     const node11 = treeMultimap.getNode(11);
     expect(node11 instanceof AVLTreeMultiMapNode);
     if (node11 instanceof AVLTreeMultiMapNode) {
-      const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), 'GT', 11);
+      const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), 1, 11);
       expect(allGreaterNodesAdded);
     }
 
@@ -564,7 +564,7 @@ describe('AVLTreeMultiMap Performance test', function () {
     }
     isDebug && console.log('---add', performance.now() - start);
     const startL = performance.now();
-    treeMS.lesserOrGreaterTraverse(node => (node.count += 1), 'LT', inputSize / 2);
+    treeMS.lesserOrGreaterTraverse(node => (node.count += 1), -1, inputSize / 2);
     isDebug && console.log('---lesserOrGreaterTraverse', performance.now() - startL);
   });
 
@@ -689,3 +689,71 @@ describe('AVLTreeMultiMap iterative methods test', () => {
     expect([...values]).toEqual(['a', 'b', 'c']);
   });
 });
+
+describe('AVLTree toEntryFn', () => {
+  it('should toEntryFn 1', () => {
+    const tree = new AVLTreeMultiMap<number, number, { obj: { id: number } }>([], {
+      toEntryFn: ele => [ele.obj.id, ele.obj.id]
+    });
+    tree.add({ obj: { id: 1 } });
+    tree.add({ obj: { id: 2 } });
+    tree.add({ obj: { id: 3 } });
+    tree.add({ obj: { id: 4 } });
+    tree.add({ obj: { id: 5 } });
+
+    const expected = [1, 2, 3, 4, 5];
+
+    expect(tree.morris(node => node.key, 'IN')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'IN')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'IN', tree.root, 'RECURSIVE')).toEqual(expected);
+  });
+
+  it('should toEntryFn 2', () => {
+    const tree = new AVLTreeMultiMap<number, number, { obj: { id: number } }>(
+      [{ obj: { id: 1 } }, { obj: { id: 2 } }, { obj: { id: 3 } }, { obj: { id: 4 } }, { obj: { id: 5 } }],
+      {
+        toEntryFn: ele => [ele.obj.id, ele.obj.id]
+      }
+    );
+
+    const expected = [1, 2, 3, 4, 5];
+
+    expect(tree.morris(node => node.key, 'IN')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'IN')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'IN', tree.root, 'RECURSIVE')).toEqual(expected);
+  });
+
+  it('should toEntryFn throw error', () => {
+    expect(
+      () =>
+        new AVLTreeMultiMap<{ obj: { id: number } }, number>([
+          { obj: { id: 1 } },
+          { obj: { id: 2 } },
+          { obj: { id: 3 } },
+          { obj: { id: 4 } },
+          { obj: { id: 5 } }
+        ])
+    ).toThrowError(
+      'When comparing two object types, it is necessary to customize a [comparator] function of options parameter during the instantiation of the data structure.'
+    );
+  });
+
+  it('should toEntryFn 3', () => {
+    const tree = new AVLTreeMultiMap<{ obj: { id: number } }, number>(
+      [{ obj: { id: 1 } }, { obj: { id: 2 } }, { obj: { id: 3 } }, { obj: { id: 4 } }, { obj: { id: 5 } }],
+      { comparator: (a, b) => a.obj.id - b.obj.id }
+    );
+
+    const expected = [
+      { obj: { id: 1 } },
+      { obj: { id: 2 } },
+      { obj: { id: 3 } },
+      { obj: { id: 4 } },
+      { obj: { id: 5 } }
+    ];
+
+    expect(tree.morris(node => node.key, 'IN')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'IN')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'IN', tree.root, 'RECURSIVE')).toEqual(expected);
+  });
+});

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

@@ -28,7 +28,7 @@ describe('AVL Tree Test', () => {
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), 'LT', 10);
+    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 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.
@@ -136,7 +136,7 @@ describe('AVL Tree Test recursively', () => {
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), 'LT', 10);
+    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 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.

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

@@ -403,6 +403,62 @@ describe('BinaryTree Morris Traversal', () => {
   });
 });
 
+describe('BinaryTree toEntryFn', () => {
+  it('should toEntryFn 1', () => {
+    const tree = new BinaryTree<number, number, { obj: { id: number } }>([], {
+      toEntryFn: ele => [ele.obj.id, ele.obj.id]
+    });
+    tree.add({ obj: { id: 1 } });
+    tree.add({ obj: { id: 2 } });
+    tree.add({ obj: { id: 3 } });
+    tree.add({ obj: { id: 4 } });
+    tree.add({ obj: { id: 5 } });
+
+    const expected = [4, 2, 5, 1, 3];
+
+    expect(tree.morris(node => node.key, 'IN')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'IN')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'IN', tree.root, 'RECURSIVE')).toEqual(expected);
+  });
+
+  it('should toEntryFn 2', () => {
+    const tree = new BinaryTree<number, number, { obj: { id: number } }>(
+      [{ obj: { id: 1 } }, { obj: { id: 2 } }, { obj: { id: 3 } }, { obj: { id: 4 } }, { obj: { id: 5 } }],
+      {
+        toEntryFn: ele => [ele.obj.id, ele.obj.id]
+      }
+    );
+
+    const expected = [4, 2, 5, 1, 3];
+
+    expect(tree.morris(node => node.key, 'IN')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'IN')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'IN', tree.root, 'RECURSIVE')).toEqual(expected);
+  });
+
+  it('should toEntryFn 3', () => {
+    const tree = new BinaryTree<{ obj: { id: number } }, number>([
+      { obj: { id: 1 } },
+      { obj: { id: 2 } },
+      { obj: { id: 3 } },
+      { obj: { id: 4 } },
+      { obj: { id: 5 } }
+    ]);
+
+    const expected = [
+      { obj: { id: 4 } },
+      { obj: { id: 2 } },
+      { obj: { id: 5 } },
+      { obj: { id: 1 } },
+      { obj: { id: 3 } }
+    ];
+
+    expect(tree.morris(node => node.key, 'IN')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'IN')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'IN', tree.root, 'RECURSIVE')).toEqual(expected);
+  });
+});
+
 describe('BinaryTree traversals', () => {
   const tree = new BinaryTree<number>();
 

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

@@ -58,7 +58,7 @@ describe('BST operations test', () => {
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    bst.lesserOrGreaterTraverse(node => (lesserSum += node.key), 'LT', 10);
+    bst.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 10);
     expect(lesserSum).toBe(45);
 
     expect(node15).toBeInstanceOf(BSTNode);
@@ -261,7 +261,7 @@ describe('BST operations test', () => {
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    objBST.lesserOrGreaterTraverse(node => (lesserSum += node.key), 'LT', 10);
+    objBST.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 10);
     expect(lesserSum).toBe(45);
 
     expect(node15).toBeInstanceOf(BSTNode);
@@ -448,7 +448,7 @@ describe('BST operations test recursively', () => {
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    bst.lesserOrGreaterTraverse(node => (lesserSum += node.key), 'LT', 10);
+    bst.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 10);
     expect(lesserSum).toBe(45);
 
     expect(node15).toBeInstanceOf(BSTNode);
@@ -649,7 +649,7 @@ describe('BST operations test recursively', () => {
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    objBST.lesserOrGreaterTraverse(node => (lesserSum += node.key), 'LT', 10);
+    objBST.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 10);
     expect(lesserSum).toBe(45);
 
     expect(node15).toBeInstanceOf(BSTNode);
@@ -869,7 +869,7 @@ describe('BST isBST', function () {
   });
 
   test('isBST when variant is Max', () => {
-    const bst = new BST<number, number>([1, 2, 3, 9, 8, 5, 6, 7, 4], { variant: 'INVERSE' });
+    const bst = new BST<number, number>([1, 2, 3, 9, 8, 5, 6, 7, 4], { comparator: (a, b) => b - a });
     bst.addMany([1, 2, 3, 9, 8, 5, 6, 7, 4]);
     expect(bst.isBST()).toBe(true);
   });
@@ -902,7 +902,7 @@ describe('BST Performance test', function () {
       node => {
         node.key - 1;
       },
-      'LT',
+      -1,
       inputSize / 2
     );
     isDebug && console.log('---lesserOrGreaterTraverse', performance.now() - startL);

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

@@ -2,7 +2,7 @@ import { AVLTree, BST, RedBlackTree, TreeMultiMap } from '../../../../src';
 
 describe('Overall BinaryTree Test', () => {
   it('should perform various operations on BinaryTree', () => {
-    const bst = new BST();
+    const bst = new BST<number>();
     bst.add(11);
     bst.add(3);
     bst.addMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5], undefined, false);
@@ -64,16 +64,19 @@ describe('Overall BinaryTree Test', () => {
   it('Should clone a BST works fine', () => {
     const bst = new BST<number>([3, 6, 7, 1, 9], {
       iterationType: 'RECURSIVE',
-      variant: 'INVERSE',
-      extractor: key => key
+      comparator: (a, b) => {
+        if (a > b) return -1;
+        if (a < b) return 1;
+        return 0;
+      }
     });
     expect(bst.size).toBe(5);
     expect(bst.root?.key).toBe(6);
-    expect(bst.root?.left?.key).toBe(7);
-    expect(bst.root?.left?.left?.key).toBe(9);
-    expect(bst.root?.right?.key).toBe(1);
-    expect(bst.root?.right?.left?.key).toBe(3);
-    expect(bst.getNodeByKey(7)?.left?.key).toBe(9);
+    expect(bst.root?.left?.key).toBe(9);
+    expect(bst.root?.left?.right?.key).toBe(7);
+    expect(bst.root?.right?.key).toBe(3);
+    expect(bst.root?.right?.right?.key).toBe(1);
+    expect(bst.getNodeByKey(9)?.right?.key).toBe(7);
     expect(bst.getHeight()).toBe(2);
     expect(bst.has(9)).toBe(true);
     expect(bst.has(7)).toBe(true);
@@ -82,31 +85,34 @@ describe('Overall BinaryTree Test', () => {
     expect(bst.size).toBe(4);
     expect(bst.root?.key).toBe(6);
     expect(bst.root?.left?.key).toBe(9);
-    expect(bst.root?.right?.key).toBe(1);
-    expect(bst.root?.right?.left?.key).toBe(3);
+    expect(bst.root?.right?.key).toBe(3);
+    expect(bst.root?.right?.right?.key).toBe(1);
     expect(bst.getNodeByKey(6)?.left?.key).toBe(9);
     expect(bst.getHeight()).toBe(2);
     expect(bst.has(9)).toBe(true);
     expect(bst.has(7)).toBe(false);
-    expect(bst.bfs()).toEqual([6, 9, 1, 3]);
+    expect(bst.bfs()).toEqual([6, 9, 3, 1]);
     const clonedBST = bst.clone();
     expect(clonedBST.size).toBe(4);
     expect(clonedBST.root?.key).toBe(6);
     expect(clonedBST.root?.left?.key).toBe(9);
-    expect(clonedBST.root?.right?.key).toBe(1);
-    expect(clonedBST.root?.right?.left?.key).toBe(3);
+    expect(clonedBST.root?.right?.key).toBe(3);
+    expect(clonedBST.root?.right?.right?.key).toBe(1);
     expect(clonedBST.getNodeByKey(6)?.left?.key).toBe(9);
     expect(clonedBST.getHeight()).toBe(2);
     expect(clonedBST.has(9)).toBe(true);
     expect(clonedBST.has(7)).toBe(false);
-    expect(clonedBST.bfs()).toEqual([6, 9, 1, 3]);
+    expect(clonedBST.bfs()).toEqual([6, 9, 3, 1]);
   });
 
   it('Should clone a AVLTree works fine', () => {
     const avl = new AVLTree<number>([3, 6, 7, 1, 9], {
       iterationType: 'RECURSIVE',
-      variant: 'INVERSE',
-      extractor: key => key
+      comparator: (a, b) => {
+        if (a > b) return -1;
+        if (a < b) return 1;
+        return 0;
+      }
     });
     expect(avl.size).toBe(5);
     avl.add(2);
@@ -148,8 +154,7 @@ describe('Overall BinaryTree Test', () => {
 
   it('Should clone a TreeMultiMap works fine', () => {
     const tmm = new TreeMultiMap<number>([3, 6, 7, 1, 9], {
-      iterationType: 'RECURSIVE',
-      extractor: key => key
+      iterationType: 'RECURSIVE'
     });
     expect(tmm.size).toBe(5);
     tmm.add(2);
@@ -197,8 +202,7 @@ describe('Overall BinaryTree Test', () => {
 
   it('Should clone a RedBlackTree works fine', () => {
     const rbTree = new RedBlackTree<number>([3, 6, 7, 1, 9], {
-      iterationType: 'RECURSIVE',
-      extractor: key => key
+      iterationType: 'RECURSIVE'
     });
     expect(rbTree.size).toBe(5);
     rbTree.add(2);

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

@@ -32,7 +32,7 @@ describe('TreeMultiMap count', () => {
       [2, 2],
       [3, 3]
     ]);
-    tmm.lesserOrGreaterTraverse(node => (node.count += 2), 'GT', 1);
+    tmm.lesserOrGreaterTraverse(node => (node.count += 2), 1, 1);
     expect(tmm.getComputedCount()).toBe(7);
     expect(tmm.count).toBe(3);
   });
@@ -93,7 +93,7 @@ describe('TreeMultiMap operations test1', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with numeric values1', () => {
-    const tmm = new TreeMultiMap();
+    const tmm = new TreeMultiMap<number, number>();
 
     expect(tmm instanceof TreeMultiMap);
 
@@ -152,7 +152,7 @@ describe('TreeMultiMap operations test1', () => {
     node15 && tmm.dfs(node => (subTreeSum += node.key), 'PRE', 15);
     expect(subTreeSum).toBe(45);
     let lesserSum = 0;
-    tmm.lesserOrGreaterTraverse((node: TreeMultiMapNode<number>) => (lesserSum += node.key), 'LT', 10);
+    tmm.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 10);
     expect(lesserSum).toBe(45);
 
     expect(node15 instanceof TreeMultiMapNode);
@@ -163,7 +163,7 @@ describe('TreeMultiMap operations test1', () => {
     const node11 = tmm.getNode(11);
     expect(node11 instanceof TreeMultiMapNode);
     if (node11 instanceof TreeMultiMapNode) {
-      const allGreaterNodesAdded = tmm.lesserOrGreaterTraverse(node => (node.count += 2), 'GT', 11);
+      const allGreaterNodesAdded = tmm.lesserOrGreaterTraverse(node => (node.count += 2), 1, 11);
       expect(allGreaterNodesAdded);
     }
 
@@ -414,7 +414,7 @@ describe('TreeMultiMap operations test recursively1', () => {
         lesserSum += node.key;
         return node.key;
       },
-      'LT',
+      -1,
       10
     );
     expect(lesserSum).toBe(45);
@@ -427,7 +427,7 @@ describe('TreeMultiMap operations test recursively1', () => {
     const node11 = tmm.getNode(11);
     expect(node11 instanceof TreeMultiMapNode);
     if (node11 instanceof TreeMultiMapNode) {
-      const allGreaterNodesAdded = tmm.lesserOrGreaterTraverse(node => (node.count += 2), 'GT', 11);
+      const allGreaterNodesAdded = tmm.lesserOrGreaterTraverse(node => (node.count += 2), 1, 11);
       expect(allGreaterNodesAdded);
     }
 

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

@@ -132,11 +132,11 @@ class MyDirectedGraph<
   VO extends MyVertex<V> = MyVertex<V>,
   EO extends MyEdge<E> = MyEdge<E>
 > extends DirectedGraph<V, E, VO, EO> {
-  createVertex(key: VertexKey, value: V): VO {
+  override createVertex(key: VertexKey, value: V): VO {
     return new MyVertex(key, value) as VO;
   }
 
-  createEdge(src: VertexKey, dest: VertexKey, weight?: number, value?: E): EO {
+  override createEdge(src: VertexKey, dest: VertexKey, weight?: number, value?: E): EO {
     return new MyEdge(src, dest, weight ?? 1, value) as EO;
   }
 

package/test/unit/utils/utils.test.ts

@@ -0,0 +1,5 @@
+describe('isNaN', () => {
+  it('should isNaN', function () {
+    expect(isNaN('string' as unknown as number)).toBe(true);
+  });
+});

package/test/utils/big-o.ts

@@ -206,14 +206,20 @@ export function logBigOMetrics(target: any, propertyKey: string, descriptor: Pro
   return descriptor;
 }
 
-export const logPerf = function (fn: (...args: any[]) => any, args: any[], thisArg?: any) {
+export const logPerf = function (
+  label: string = 'function running cost',
+  fn: (...args: any[]) => any,
+  args: any[],
+  thisArg?: any
+) {
   const start = performance.now();
+  let result: any;
   if (thisArg) {
-    if (args && args.length > 0) fn.apply(thisArg, args);
-    else fn.apply(thisArg);
+    if (args && args.length > 0) result = fn.apply(thisArg, args);
+    else result = fn.apply(thisArg);
   } else {
-    if (args && args.length > 0) fn(...args);
-    else fn();
+    if (args && args.length > 0) result = fn(...args);
+    else result = fn();
   }
-  console.log(`function running cost : ${(performance.now() - start).toFixed(2)} ms`);
+  console.log(`${(performance.now() - start).toFixed(2)} ms, ${label}, ${result}`);
 };

package/test/utils/console.ts

@@ -1,4 +1,4 @@
-export const Color = {
+export const ConsoleColor = {
   END: '\x1b[0m',
   BOLD: '\x1b[1m',
   DIM: '\x1b[2m',

package/tsconfig-base.json

@@ -16,6 +16,7 @@
     "strict": true,                       // Enable strict type checking, including enabling all strict options.
     "traceResolution": false,             // Whether to trace the module resolution process.
     "types": ["node", "jest"],            // Specifies the name of the type declaration file to include.
+    "noImplicitOverride": true,
     "typeRoots": ["node_modules/@types", "src/types", "test/types"]
   },
   "compileOnSave": false,                 // Whether to automatically compile when saving.