data-structure-typed 1.48.4 → 1.48.6

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

@@ -5,7 +5,7 @@ import { magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
-const { LINEAR } = magnitude;
+const { LINEAR, HUNDRED_THOUSAND } = magnitude;
 
 suite.add(`${LINEAR.toLocaleString()} push`, () => {
   const queue = new Queue<number>();
@@ -15,7 +15,7 @@ suite.add(`${LINEAR.toLocaleString()} push`, () => {
   }
 });
 if (isCompetitor) {
-  suite.add(`${LINEAR.toLocaleString()} CPT push`, () => {
+  suite.add(`CPT ${LINEAR.toLocaleString()} push`, () => {
     const queue = new CQueue<number>();
 
     for (let i = 0; i < LINEAR; i++) {
@@ -23,13 +23,36 @@ if (isCompetitor) {
     }
   });
 }
-suite.add(`${LINEAR.toLocaleString()} push & shift`, () => {
+suite.add(`${HUNDRED_THOUSAND.toLocaleString()} push & shift`, () => {
   const queue = new Queue<number>();
 
-  for (let i = 0; i < LINEAR; i++) {
+  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`, () => {
+    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.pop();
+    }
+  });
 
 export { suite };

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

@@ -15,7 +15,7 @@ suite.add(`${LINEAR.toLocaleString()} push`, () => {
   }
 });
 if (isCompetitor) {
-  suite.add(`${LINEAR.toLocaleString()} CPT push`, () => {
+  suite.add(`CPT ${LINEAR.toLocaleString()} push`, () => {
     const queue = new CStack<number>();
 
     for (let i = 0; i < LINEAR; i++) {
@@ -34,7 +34,7 @@ suite.add(`${LINEAR.toLocaleString()} push & pop`, () => {
   }
 });
 if (isCompetitor) {
-  suite.add(`${LINEAR.toLocaleString()} CPT push & pop`, () => {
+  suite.add(`CPT ${LINEAR.toLocaleString()} push & pop`, () => {
     const queue = new CStack<number>();
 
     for (let i = 0; i < LINEAR; i++) {

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

@@ -569,7 +569,7 @@ describe('BinaryTree iterative methods test', () => {
   beforeEach(() => {
     binaryTree = new BinaryTree();
     binaryTree.add([1, 'a']);
-    binaryTree.add([2, 'b']);
+    binaryTree.add(2, 'b');
     binaryTree.add([3, 'c']);
   });
 

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

@@ -10,7 +10,7 @@ describe('BST operations test', () => {
     bst.add([11, 11]);
     bst.add([3, 3]);
     const idsAndValues: [number, number][] = [[15, 15], [1, 1], [8, 8], [13, 13], [16, 16], [2, 2], [6, 6], [9, 9], [12, 12], [14, 14], [4, 4], [7, 7], [10, 10], [5, 5]];
-    bst.addMany(idsAndValues, false);
+    bst.addMany(idsAndValues, undefined, false);
     expect(bst.root).toBeInstanceOf(BSTNode);
 
     if (bst.root) expect(bst.root.key).toBe(11);
@@ -189,28 +189,27 @@ describe('BST operations test', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objBST = new BST<number, { key: number; keyA: number }>();
+    const objBST = new BST<number, { name: string; age: number }>();
     expect(objBST).toBeInstanceOf(BST);
-    objBST.add([11, { key: 11, keyA: 11 }]);
-    objBST.add([3, { key: 3, keyA: 3 }]);
-    const values: [number, { key: number; keyA: number }][] = [
-      [15, { key: 15, keyA: 15 }],
-      [1, { key: 1, keyA: 1 }],
-      [8, { key: 8, keyA: 8 }],
-      [13, { key: 13, keyA: 13 }],
-      [16, { key: 16, keyA: 16 }],
-      [2, { key: 2, keyA: 2 }],
-      [6, { key: 6, keyA: 6 }],
-      [9, { key: 9, keyA: 9 }],
-      [12, { key: 12, keyA: 12 }],
-      [14, { key: 14, keyA: 14 }],
-      [4, { key: 4, keyA: 4 }],
-      [7, { key: 7, keyA: 7 }],
-      [10, { key: 10, keyA: 10 }],
-      [5, { key: 5, keyA: 5 }]
-    ];
-
-    objBST.addMany(values, false);
+    objBST.add([11, { name: '11', age: 11 }]);
+    objBST.add([3, { name: '3', age: 3 }]);
+
+    objBST.addMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5], [
+      { "name": "Alice", "age": 15 },
+      { "name": "Bob", "age": 1 },
+      { "name": "Charlie", "age": 8 },
+      { "name": "David", "age": 13 },
+      { "name": "Emma", "age": 16 },
+      { "name": "Frank", "age": 2 },
+      { "name": "Grace", "age": 6 },
+      { "name": "Hannah", "age": 9 },
+      { "name": "Isaac", "age": 12 },
+      { "name": "Jack", "age": 14 },
+      { "name": "Katie", "age": 4 },
+      { "name": "Liam", "age": 7 },
+      { "name": "Mia", "age": 10 },
+      { "name": "Noah", "age": 5 }
+    ], false);
 
     expect(objBST.root).toBeInstanceOf(BSTNode);
 
@@ -232,7 +231,7 @@ describe('BST operations test', () => {
     expect(leftMost?.key).toBe(1);
 
     const node15 = objBST.getNode(15);
-    expect(node15?.value).toEqual({ key: 15, keyA: 15 });
+    expect(node15?.value).toEqual({ name: 'Alice', age: 15 });
     const minNodeBySpecificNode = node15 && objBST.getLeftMost(node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
 
@@ -256,7 +255,7 @@ describe('BST operations test', () => {
     objBST.perfectlyBalance();
     expect(objBST.isPerfectlyBalanced()).toBe(true);
 
-    const bfsNodesAfterBalanced: BSTNode<number, { key: number; keyA: number }>[] = [];
+    const bfsNodesAfterBalanced: BSTNode<number, { name: string; age: number }>[] = [];
     objBST.bfs(node => bfsNodesAfterBalanced.push(node));
     expect(bfsNodesAfterBalanced[0].key).toBe(8);
     expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
@@ -381,7 +380,7 @@ describe('BST operations test', () => {
     expect(bfsIDs[1]).toBe(12);
     expect(bfsIDs[2]).toBe(16);
 
-    const bfsNodes: BSTNode<number, { key: number; keyA: number }>[] = [];
+    const bfsNodes: BSTNode<number, { name: string; age: number }>[] = [];
     objBST.bfs(node => bfsNodes.push(node));
     expect(bfsNodes[0].key).toBe(2);
     expect(bfsNodes[1].key).toBe(12);
@@ -396,7 +395,7 @@ describe('BST operations test recursively', () => {
     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, false);
+    bst.addMany(idsAndValues, undefined, false);
     expect(bst.root).toBeInstanceOf(BSTNode);
 
     if (bst.root) expect(bst.root.key).toBe(11);
@@ -580,7 +579,7 @@ describe('BST operations test recursively', () => {
     expect(objBST).toBeInstanceOf(BST);
     objBST.add([11, { key: 11, keyA: 11 }]);
     objBST.add([3, { key: 3, keyA: 3 }]);
-    const values: [number, { key: number; keyA: number }][] = [
+    const entries: [number, { key: number; keyA: number }][] = [
       [15, { key: 15, keyA: 15 }],
       [1, { key: 1, keyA: 1 }],
       [8, { key: 8, keyA: 8 }],
@@ -598,7 +597,8 @@ describe('BST operations test recursively', () => {
     ];
 
     objBST.addMany(
-      values,
+      entries,
+      undefined,
       false
     );
 
@@ -829,7 +829,7 @@ describe('BST Performance test', function () {
 
   it('should the lastKey of a BST to be the largest key', function () {
     const bst = new BST();
-    bst.addMany([9, 8, 7, 3, 1, 2, 5, 4, 6], false);
+    bst.addMany([9, 8, 7, 3, 1, 2, 5, 4, 6], undefined, false);
     // TODO
     // expect(bst.lastKey()).toBe(9);
   });

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], false);
+    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

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

@@ -605,9 +605,9 @@ describe('TreeMultimap iterative methods test', () => {
   let treeMM: TreeMultimap<number, string>;
   beforeEach(() => {
     treeMM = new TreeMultimap<number, string>();
-    treeMM.add([1, 'a'], 10);
-    treeMM.add([2, 'b'], 10);
-    treeMM.add([3, 'c'], 1);
+    treeMM.add(1, 'a', 10);
+    treeMM.add([2, 'b'], undefined, 10);
+    treeMM.add([3, 'c'], undefined, 1);
   });
 
   test('The node obtained by get Node should match the node type', () => {

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

@@ -7,7 +7,7 @@ describe('DirectedGraph Operation Test', () => {
     graph = new DirectedGraph();
   });
 
-  it('should add vertices', () => {
+  it('should add vertexMap', () => {
     const vertex1 = new DirectedVertex('A');
     const vertex2 = new DirectedVertex('B');
 
@@ -155,7 +155,7 @@ describe('Inherit from DirectedGraph and perform operations', () => {
     myGraph = new MyDirectedGraph();
   });
 
-  it('Add vertices', () => {
+  it('Add vertexMap', () => {
     myGraph.addVertex(1, 'data1');
     myGraph.addVertex(2, 'data2');
     myGraph.addVertex(3, 'data3');
@@ -204,7 +204,7 @@ describe('Inherit from DirectedGraph and perform operations', () => {
     expect(true).toBeTruthy();
   });
 
-  it('Remove edge between vertices', () => {
+  it('Remove edge between vertexMap', () => {
     myGraph.addVertex(1, 'data1');
     myGraph.addVertex(2, 'data2');
     myGraph.addEdge(1, 2, 10, 'edge-data1-2');
@@ -232,14 +232,14 @@ describe('Inherit from DirectedGraph and perform operations', () => {
     }
   });
 
-  it('Minimum path between vertices', () => {
+  it('Minimum path between vertexMap', () => {
     myGraph.addVertex(new MyVertex(1, 'data1'));
     myGraph.addVertex(new MyVertex(2, 'data2'));
     myGraph.addEdge(new MyEdge(1, 2, 10, 'edge-data1-2'));
   });
 
-  it('All paths between vertices', () => {
-    // Add vertices and edges as needed for this test
+  it('All paths between vertexMap', () => {
+    // Add vertexMap and edges as needed for this test
     myGraph.addVertex(new MyVertex(1, 'data1'));
     myGraph.addVertex(new MyVertex(2, 'data2'));
     myGraph.addEdge(new MyEdge(1, 2, 10, 'edge-data1-2'));
@@ -598,41 +598,41 @@ describe('cycles, strongly connected components, bridges, articular points in Di
 
 describe('DirectedGraph iterative Methods', () => {
   let graph: DirectedGraph<string>;
-  let vertices: string[];
+  let vertexMap: string[];
 
   beforeEach(() => {
     graph = new DirectedGraph();
-    vertices = ['A', 'B', 'C', 'D'];
-    vertices.forEach(vertex => graph.addVertex(vertex));
+    vertexMap = ['A', 'B', 'C', 'D'];
+    vertexMap.forEach(vertex => graph.addVertex(vertex));
   });
 
-  test('[Symbol.iterator] should iterate over all vertices', () => {
+  test('[Symbol.iterator] should iterate over all vertexMap', () => {
     const iteratedVertices = [];
     for (const vertex of graph) {
       iteratedVertices.push(vertex[0]);
     }
-    expect(iteratedVertices).toEqual(vertices);
+    expect(iteratedVertices).toEqual(vertexMap);
   });
 
   test('forEach should apply a function to each vertex', () => {
     const result: VertexKey[] = [];
     graph.forEach((value, key) => key && result.push(key));
-    expect(result).toEqual(vertices);
+    expect(result).toEqual(vertexMap);
   });
 
-  test('filter should return vertices that satisfy the condition', () => {
+  test('filter should return vertexMap that satisfy the condition', () => {
     const filtered = graph.filter((value, vertex) => vertex === 'A' || vertex === 'B');
     expect(filtered).toEqual([["A", undefined], ["B", undefined]]);
   });
 
   test('map should apply a function to each vertex and return a new array', () => {
     const mapped = graph.map((value, vertex) => vertex + '_mapped');
-    expect(mapped).toEqual(vertices.map(v => v + '_mapped'));
+    expect(mapped).toEqual(vertexMap.map(v => v + '_mapped'));
   });
 
   test('reduce should accumulate a value based on each vertex', () => {
     const concatenated = graph.reduce((acc, value, key) => acc + key, '');
-    expect(concatenated).toBe(vertices.join(''));
+    expect(concatenated).toBe(vertexMap.join(''));
   });
 
   test('Removing an edge of a DirectedGraph should not delete additional edges', () => {

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

@@ -52,8 +52,8 @@ describe('MapGraph', () => {
     mapGraph = new MapGraph<string, string>([0, 0], [100, 100]);
   });
 
-  // Test adding vertices to the graph
-  it('should add vertices to the graph', () => {
+  // Test adding vertexMap to the graph
+  it('should add vertexMap to the graph', () => {
     const locationA = new MapVertex('A', 'Location A', 10, 20);
     const locationB = new MapVertex('B', 'Location B', 30, 40);
 
@@ -88,7 +88,7 @@ describe('MapGraph', () => {
     const edgeAB = new MapEdge('A', 'B', 50, 'Edge from A to B');
     const edgeBC = new MapEdge('B', 'C', 60, 'Edge from B to C');
 
-    expect(mapGraph.origin).toEqual([0, 0]);
+    expect(mapGraph.originCoord).toEqual([0, 0]);
     expect(mapGraph.bottomRight).toEqual([100, 100]);
 
     mapGraph.addVertex(locationA);

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

@@ -17,7 +17,7 @@ describe('UndirectedGraph Operation Test', () => {
     expect(graph.getEndsOfEdge(new UndirectedEdge('c', 'd'))).toBe(undefined);
   });
 
-  it('should add vertices', () => {
+  it('should add vertexMap', () => {
     const vertex1 = new UndirectedVertex('A');
     const vertex2 = new UndirectedVertex('B');
 
@@ -76,8 +76,8 @@ describe('UndirectedGraph', () => {
     undirectedGraph = new UndirectedGraph<string, string>();
   });
 
-  // Test adding vertices to the graph
-  it('should add vertices to the graph', () => {
+  // Test adding vertexMap to the graph
+  it('should add vertexMap to the graph', () => {
     const vertexA = new UndirectedVertex('A', 'Location A');
     const vertexB = new UndirectedVertex('B', 'Location B');
 
@@ -130,8 +130,8 @@ describe('UndirectedGraph', () => {
     const edgeAB = new UndirectedEdge('A', 'B', 3, 'Edge between A and B');
     const edgeBC = new UndirectedEdge('B', 'C', 4, 'Edge between B and C');
 
-    edgeAB.vertices = edgeAB.vertices;
-    expect(undirectedGraph.edges.size).toBe(0);
+    edgeAB.vertexMap = edgeAB.vertexMap;
+    expect(undirectedGraph.edgeMap.size).toBe(0);
     undirectedGraph.addVertex(vertexA);
     undirectedGraph.addVertex(vertexB);
     undirectedGraph.addVertex(vertexC);
@@ -181,10 +181,10 @@ describe('UndirectedGraph', () => {
     dg.addVertex('hey')
     dg.addEdge('hello', 'hi')
     dg.addEdge('hello', 'hey')
-    expect(dg.getEdge('hello', 'hi')?.vertices[0]).toBe('hello')
-    expect(dg.getEdge('hello', 'hi')?.vertices[1]).toBe('hi')
-    expect(dg.getEdge('hello', 'hey')?.vertices[0]).toBe('hello')
-    expect(dg.getEdge('hello', 'hey')?.vertices[1]).toBe('hey')
+    expect(dg.getEdge('hello', 'hi')?.vertexMap[0]).toBe('hello')
+    expect(dg.getEdge('hello', 'hi')?.vertexMap[1]).toBe('hi')
+    expect(dg.getEdge('hello', 'hey')?.vertexMap[0]).toBe('hello')
+    expect(dg.getEdge('hello', 'hey')?.vertexMap[1]).toBe('hey')
     dg.deleteEdge('hello', 'hi')
     expect(dg.getEdge('hello', 'hi')).toBe(undefined)
     expect(dg.getEdge('hello', 'hey')).toBeInstanceOf(UndirectedEdge)
@@ -200,13 +200,13 @@ describe('UndirectedGraph', () => {
     dg.addEdge('hello', 'earth')
     dg.addEdge('world', 'earth')
 
-    expect(dg.getEdge('hello', 'world')?.vertices[0]).toBe('hello');
+    expect(dg.getEdge('hello', 'world')?.vertexMap[0]).toBe('hello');
     expect(dg.edgeSet().length).toBe(3)
-    expect(dg.edgeSet()[0].vertices).toEqual(['hello', 'world'])
+    expect(dg.edgeSet()[0].vertexMap).toEqual(['hello', 'world'])
 
     dg.deleteVertex('hello')
     expect(dg.edgeSet().length).toBe(1)
-    expect(dg.edgeSet()?.[0].vertices[0]).toBe('world')
+    expect(dg.edgeSet()?.[0].vertexMap[0]).toBe('world')
 
     expect(dg.getEdge('hello', 'world')).toBe(undefined);
   })