data-structure-typed 1.50.1 → 1.50.3

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

@@ -795,6 +795,70 @@ describe('BST operations test recursively', () => {
     expect(bfsNodes[1].key).toBe(12);
     expect(bfsNodes[2].key).toBe(16);
   });
+
+  it('should delete', () => {
+    const numBST = new BST<number>();
+    numBST.addMany([2, 4, 5, 3, 1]);
+    expect(numBST.size).toBe(5);
+    numBST.delete(1);
+    expect(numBST.size).toBe(4);
+
+    numBST.delete(2);
+    numBST.delete(3);
+    numBST.delete(4);
+    numBST.delete(5);
+    expect(numBST.size).toBe(0);
+    numBST.delete(5);
+    expect(numBST.size).toBe(0);
+  });
+
+  it('should the clone method', () => {
+    function checkTreeStructure(bst: BST<string, number>) {
+      expect(bst.size).toBe(4);
+      expect(bst.root?.key).toBe('2');
+      expect(bst.root?.left?.key).toBe('1');
+      expect(bst.root?.left?.left?.key).toBe(undefined);
+      expect(bst.root?.left?.right?.key).toBe(undefined);
+      expect(bst.root?.right?.key).toBe('4');
+      expect(bst.root?.right?.left?.key).toBe(undefined);
+      expect(bst.root?.right?.right?.key).toBe('5');
+    }
+
+    const bst = new BST<string, number>();
+    bst.addMany([
+      ['2', 2],
+      ['4', 4],
+      ['5', 5],
+      ['3', 3],
+      ['1', 1]
+    ]);
+    expect(bst.size).toBe(5);
+    expect(bst.root?.key).toBe('3');
+    expect(bst.root?.left?.key).toBe('1');
+    expect(bst.root?.left?.left?.key).toBe(undefined);
+    expect(bst.root?.left?.right?.key).toBe('2');
+    expect(bst.root?.right?.key).toBe('4');
+    expect(bst.root?.right?.left?.key).toBe(undefined);
+    expect(bst.root?.right?.right?.key).toBe('5');
+    bst.delete('3');
+    checkTreeStructure(bst);
+    const cloned = bst.clone();
+    checkTreeStructure(cloned);
+    bst.delete('2');
+    bst.delete('1');
+    bst.delete('4');
+    bst.delete('5');
+    expect(bst.size).toBe(0);
+
+    cloned.delete('1');
+    expect(bst.size).toBe(0);
+    expect(cloned.size).toBe(3);
+    cloned.delete('2');
+    cloned.delete('3');
+    cloned.delete('4');
+    cloned.delete('5');
+    expect(cloned.size).toBe(0);
+  });
 });
 
 describe('BST isBST', function () {
@@ -865,7 +929,7 @@ describe('BST Performance test', function () {
     // expect(bst.lastKey()).toBe(9);
   });
 
-  it('should subTreeTraverse, null should be ignored', () => {
+  it('should dfs as sub tree traversal, null should be ignored', () => {
     const bst = new BST();
     bst.addMany([4, 2, 6, 1, 3, 5, 7]);
     expect(bst.dfs(node => node.key, 'pre', bst.getNode(6), IterationType.ITERATIVE)).toEqual([6, 5, 7]);

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

@@ -138,9 +138,46 @@ describe('RedBlackTree', () => {
       expect(predecessorNode).toBe(tree.getNode(10));
     });
   });
+
+  it('should the clone method', () => {
+    function checkTreeStructure(rbTree: RedBlackTree<string, number>) {
+      expect(rbTree.size).toBe(4);
+      expect(rbTree.root?.key).toBe('2');
+      expect(rbTree.root?.left?.key).toBe('1');
+      expect(rbTree.root?.left?.left?.key).toBe(NaN);
+      expect(rbTree.root?.left?.right?.key).toBe(NaN);
+      expect(rbTree.root?.right?.key).toBe('4');
+      expect(rbTree.root?.right?.left?.key).toBe(NaN);
+      expect(rbTree.root?.right?.right?.key).toBe('5');
+    }
+
+    const rbTree = new RedBlackTree<string, number>();
+    rbTree.addMany([
+      ['2', 2],
+      ['4', 4],
+      ['5', 5],
+      ['3', 3],
+      ['1', 1]
+    ]);
+    expect(rbTree.size).toBe(5);
+    expect(rbTree.root?.key).toBe('2');
+    expect(rbTree.root?.left?.key).toBe('1');
+    expect(rbTree.root?.left?.left?.key).toBe(NaN);
+    expect(rbTree.root?.left?.right?.key).toBe(NaN);
+    expect(rbTree.root?.right?.key).toBe('4');
+    expect(rbTree.root?.right?.left?.key).toBe('3');
+    expect(rbTree.root?.right?.right?.key).toBe('5');
+    rbTree.delete('3');
+    checkTreeStructure(rbTree);
+    const cloned = rbTree.clone();
+    checkTreeStructure(cloned);
+    cloned.delete('1');
+    expect(rbTree.size).toBe(4);
+    expect(cloned.size).toBe(3);
+  });
 });
 
-describe('RedBlackTree', () => {
+describe('RedBlackTree 2', () => {
   let tree: RedBlackTree<number>;
 
   beforeEach(() => {

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

@@ -555,38 +555,6 @@ describe('TreeMultimap Performance test', function () {
   beforeEach(() => {
     treeMS.clear();
   });
-  it(`Observe the time consumption of TreeMultimap.add fitting O(n log n)`, function () {
-    // // Create a benchmark suite
-    // const suite = new Benchmark.Suite();
-    // // Define a function to generate a random array of a given size
-    // function generateRandomArray(size: number): number[] {
-    //   const arr: number[] = [];
-    //   for (let i = 0; i < size; i++) {
-    //     arr.push(Math.floor(Math.random() * size));
-    //   }
-    //   return arr;
-    // }
-    // const inputArray = generateRandomArray(inputSize[0]);
-    //
-    // suite.add(`TreeMultimap addMany (n=${inputSize[0]})`, () => {
-    //   treeMS.addMany([...inputArray]);
-    // });
-    //
-    // // Run the benchmarks
-    // suite
-    //   .on('cycle', (event: any) => {
-    //     const benchmark = event.target;
-    //     const n = parseInt(benchmark.name.split('=')[1]);
-    //     const observedTime = benchmark.times.elapsed;
-    //     const expected = expectedTime(n);
-    //     console.log(`Input size (n): ${n}, Observed time: ${observedTime.toFixed(2)}ms, Expected time: ${expected.toFixed(2)}ms`);
-    //   })
-    //   .on('complete', () => {
-    //     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 TreeMultimap.dfs be good`, function () {
     const startDFS = performance.now();
@@ -604,6 +572,43 @@ describe('TreeMultimap Performance test', function () {
     treeMS.lesserOrGreaterTraverse(node => (node.count += 1), CP.lt, inputSize / 2);
     isDebug && console.log('---lesserOrGreaterTraverse', performance.now() - startL);
   });
+
+  it('should the clone method', () => {
+    function checkTreeStructure(treeMultimap: TreeMultimap<string, number>) {
+      expect(treeMultimap.size).toBe(4);
+      expect(treeMultimap.root?.key).toBe('2');
+      expect(treeMultimap.root?.left?.key).toBe('1');
+      expect(treeMultimap.root?.left?.left?.key).toBe(undefined);
+      expect(treeMultimap.root?.left?.right?.key).toBe(undefined);
+      expect(treeMultimap.root?.right?.key).toBe('4');
+      expect(treeMultimap.root?.right?.left?.key).toBe(undefined);
+      expect(treeMultimap.root?.right?.right?.key).toBe('5');
+    }
+
+    const treeMultimap = new TreeMultimap<string, number>();
+    treeMultimap.addMany([
+      ['2', 2],
+      ['4', 4],
+      ['5', 5],
+      ['3', 3],
+      ['1', 1]
+    ]);
+    expect(treeMultimap.size).toBe(5);
+    expect(treeMultimap.root?.key).toBe('2');
+    expect(treeMultimap.root?.left?.key).toBe('1');
+    expect(treeMultimap.root?.left?.left?.key).toBe(undefined);
+    expect(treeMultimap.root?.left?.right?.key).toBe(undefined);
+    expect(treeMultimap.root?.right?.key).toBe('4');
+    expect(treeMultimap.root?.right?.left?.key).toBe('3');
+    expect(treeMultimap.root?.right?.right?.key).toBe('5');
+    treeMultimap.delete('3');
+    checkTreeStructure(treeMultimap);
+    const cloned = treeMultimap.clone();
+    checkTreeStructure(cloned);
+    cloned.delete('1');
+    expect(treeMultimap.size).toBe(4);
+    expect(cloned.size).toBe(3);
+  });
 });
 
 describe('TreeMultimap iterative methods test', () => {

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

@@ -77,6 +77,17 @@ class MyGraph<
     return true;
   }
 
+  isEmpty(): boolean {
+    return true;
+  }
+
+  clear(): void {
+  }
+
+  clone(): any {
+    return {};
+  }
+
   protected _addEdge(edge: EO): boolean {
     return edge ? true : true;
   }

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

@@ -78,7 +78,7 @@ describe('DirectedGraph Operation Test', () => {
     expect(graph.outDegreeOf(vertexC)).toBe(0);
     expect(graph.edgesOf(vertexC)?.length).toBe(1);
 
-    expect(graph.tarjan(true, true, true, true)?.dfnMap.size).toBe(3);
+    expect(graph.tarjan().dfnMap.size).toBe(3);
     expect(graph.bellmanFord(vertexC, true, true, true)?.paths.length).toBe(3);
     expect(graph.getMinPathBetween('B', 'C', true)?.length).toBe(2);
     expect(graph.setEdgeWeight('B', 'C', 100)).toBe(true);
@@ -634,14 +634,14 @@ describe('cycles, strongly connected components, bridges, articular points in Di
   graph.addEdge('H', 'F');
   const cycles = graph.getCycles();
   const scCs = graph.getSCCs();
-  const bridges = graph.getBridges();
-  const cutVertexes = graph.getCutVertexes();
+  // const bridges = graph.getBridges();
+  // const cutVertices = graph.getCutVertices();
   const dfnMap = graph.getDFNMap();
   const lowMap = graph.getLowMap();
   expect(cycles.length).toBe(2);
   expect(scCs.size).toBe(5);
-  expect(bridges.length).toBe(4);
-  expect(cutVertexes.length).toBe(4);
+  // expect(bridges.length).toBe(4);
+  // expect(cutVertices.length).toBe(4);
   expect(dfnMap.size).toBe(8);
   expect(lowMap.size).toBe(8);
 });
@@ -810,3 +810,188 @@ describe('DirectedGraph getCycles', () => {
     ]);
   });
 });
+
+describe('DirectedGraph tarjan', () => {
+  test('should simple cycles graph tarjan cycles return correct result', () => {
+    const graph = new DirectedGraph();
+
+    graph.addVertex('A');
+    graph.addVertex('B');
+    graph.addVertex('C');
+    graph.addVertex('D');
+
+    graph.addEdge('A', 'B');
+    graph.addEdge('B', 'C');
+    graph.addEdge('C', 'A');
+    graph.addEdge('A', 'D');
+    graph.addEdge('D', 'C');
+    const cycles = graph.getCycles();
+    expect(cycles.length).toBe(2);
+    expect(cycles).toEqual([
+      ['A', 'B', 'C'],
+      ['A', 'D', 'C']
+    ]);
+  });
+
+  function getAsVerticesArrays(vss: Map<number, DirectedVertex<any>[]>) {
+    return [...vss.values()].map(vs => vs.map(vertex => vertex.key));
+  }
+
+  function createExampleGraph1() {
+    const graph = new DirectedGraph();
+    graph.addVertex('A');
+    graph.addVertex('B');
+    graph.addVertex('C');
+    graph.addVertex('D');
+    graph.addVertex('E');
+    graph.addEdge('A', 'B');
+    graph.addEdge('A', 'C');
+    graph.addEdge('B', 'D');
+    graph.addEdge('C', 'D');
+    graph.addEdge('D', 'E');
+    graph.addEdge('E', 'B');
+    return graph;
+  }
+
+  test('should tarjan cycles return correct result', () => {
+    const graph = createExampleGraph1();
+    const cycles = graph.getCycles();
+    expect(cycles.length).toBe(1);
+    expect(cycles).toEqual([['B', 'D', 'E']]);
+  });
+
+  test('should tarjan SCCs return correct result', () => {
+    const graph = createExampleGraph1();
+    const sccs = graph.tarjan().SCCs;
+    expect(sccs.size).toBe(3);
+    expect(getAsVerticesArrays(sccs)).toEqual([['E', 'D', 'B'], ['C'], ['A']]);
+  });
+
+  function createExampleGraph2() {
+    const graph = createExampleGraph1();
+    graph.addVertex('F');
+    graph.addVertex('G');
+    graph.addEdge('B', 'F');
+    graph.addEdge('F', 'E');
+    graph.addEdge('C', 'G');
+    graph.addEdge('G', 'A');
+    return graph;
+  }
+
+  test('should 3 cycles graph tarjan cycles return correct result', () => {
+    const graph = createExampleGraph2();
+    const cycles = graph.getCycles();
+    expect(cycles.length).toBe(3);
+    expect(cycles).toEqual([
+      ['A', 'C', 'G'],
+      ['B', 'D', 'E'],
+      ['B', 'F', 'E']
+    ]);
+  });
+
+  test('should 3 cycles graph tarjan SCCs return correct result', () => {
+    const graph = createExampleGraph2();
+    const sccs = graph.tarjan().SCCs;
+    expect(sccs.size).toBe(2);
+    expect(getAsVerticesArrays(sccs)).toEqual([
+      ['F', 'E', 'D', 'B'],
+      ['G', 'C', 'A']
+    ]);
+  });
+
+  function createExampleGraph3() {
+    const graph = new DirectedGraph();
+    graph.addVertex('A');
+    graph.addVertex('B');
+    graph.addVertex('C');
+    graph.addVertex('D');
+    graph.addVertex('E');
+    graph.addVertex('F');
+    graph.addVertex('G');
+    graph.addEdge('A', 'B');
+    graph.addEdge('B', 'C');
+    graph.addEdge('C', 'D');
+    graph.addEdge('D', 'B');
+    graph.addEdge('A', 'E');
+    graph.addEdge('E', 'F');
+    graph.addEdge('F', 'G');
+    graph.addEdge('G', 'E');
+    return graph;
+  }
+
+  test('should cuttable graph tarjan cycles return correct result', () => {
+    const graph = createExampleGraph3();
+    const cycles = graph.getCycles();
+    expect(cycles.length).toBe(2);
+    expect(cycles).toEqual([
+      ['B', 'C', 'D'],
+      ['E', 'F', 'G']
+    ]);
+  });
+
+  test('should cuttable graph tarjan SCCs return correct result', () => {
+    const graph = createExampleGraph3();
+    const sccs = graph.tarjan().SCCs;
+    expect(sccs.size).toBe(3);
+    expect(getAsVerticesArrays(sccs)).toEqual([['D', 'C', 'B'], ['G', 'F', 'E'], ['A']]);
+  });
+
+  function createExampleGraph4() {
+    const graph = createExampleGraph3();
+    graph.addVertex('H');
+    graph.addVertex('I');
+    graph.addVertex('J');
+    graph.addVertex('K');
+    graph.addEdge('C', 'H');
+    graph.addEdge('H', 'I');
+    graph.addEdge('I', 'D');
+    graph.addEdge('H', 'J');
+    graph.addEdge('J', 'K');
+    graph.addEdge('K', 'H');
+    return graph;
+  }
+
+  test('should more cuttable graph tarjan cycles return correct result', () => {
+    const graph = createExampleGraph4();
+    const cycles = graph.getCycles();
+    expect(cycles.length).toBe(4);
+    expect(cycles).toEqual([
+      ['B', 'C', 'D'],
+      ['B', 'C', 'H', 'I', 'D'],
+      ['E', 'F', 'G'],
+      ['H', 'J', 'K']
+    ]);
+  });
+
+  test('should more cuttable graph tarjan SCCs return correct result', () => {
+    const graph = createExampleGraph4();
+    const sccs = graph.tarjan().SCCs;
+    expect(sccs.size).toBe(3);
+    expect(getAsVerticesArrays(sccs)).toEqual([['K', 'J', 'I', 'H', 'D', 'C', 'B'], ['G', 'F', 'E'], ['A']]);
+  });
+
+  function createExampleGraph5() {
+    const graph = createExampleGraph4();
+    graph.addEdge('F', 'H');
+    return graph;
+  }
+
+  test('should uncuttable graph tarjan cycles return correct result', () => {
+    const graph = createExampleGraph5();
+    const cycles = graph.getCycles();
+    expect(cycles.length).toBe(4);
+    expect(cycles).toEqual([
+      ['B', 'C', 'D'],
+      ['B', 'C', 'H', 'I', 'D'],
+      ['E', 'F', 'G'],
+      ['H', 'J', 'K']
+    ]);
+  });
+
+  test('should uncuttable graph tarjan SCCs return correct result', () => {
+    const graph = createExampleGraph5();
+    const sccs = graph.tarjan().SCCs;
+    expect(sccs.size).toBe(3);
+    expect(getAsVerticesArrays(sccs)).toEqual([['K', 'J', 'I', 'H', 'D', 'C', 'B'], ['G', 'F', 'E'], ['A']]);
+  });
+});