data-structure-typed 1.33.0 → 1.33.5

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

@@ -0,0 +1,43 @@
+// import {RBTree, RBTreeNode} from '../../../../src';
+
+describe('Red-Black Tree Tests', () => {
+  // let tree: RBTree<RBTreeNode<number>>;
+  //
+  // beforeEach(() => {
+  //   tree = new RBTree<RBTreeNode<number>>();
+  // });
+
+  test('Insertion and In-order Traversal', () => {
+    // tree.add(5);
+    // tree.add(3);
+    // tree.add(7);
+    // tree.add(2);
+    // tree.add(4);
+    // tree.add(6);
+    // tree.add(8);
+    //
+    // const inOrderTraversal: number[] = tree.DFS('in')
+    //
+    // expect(inOrderTraversal).toEqual([2, 3, 4, 5, 6, 7, 8]);
+  });
+
+  test('Deletion', () => {
+    // tree.add(5);
+    // tree.add(3);
+    // tree.add(7);
+    // tree.add(2);
+    // tree.add(4);
+    // tree.add(6);
+    // tree.add(8);
+    //
+    // // Delete a node (e.g., 3) and check if it's gone
+    // tree.remove(3);
+    // expect(tree.has(3)).toBe(false);
+    //
+    // // Perform in-order traversal to check if the tree is still balanced
+    // const inOrderTraversal: number[] = tree.DFS('in');
+    //
+    //
+    // expect(inOrderTraversal).toEqual([2, 4, 5, 6, 7, 8]);
+  });
+});

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

@@ -15,7 +15,7 @@ describe('TreeMultiset operations test', () => {
 
     expect(treeMultiset.size).toBe(16);
     expect(treeMultiset.count).toBe(18);
-    expect(treeMultiset.BFS('id'))
+    expect(treeMultiset.BFS('id'));
 
     expect(treeMultiset.has(6));
 
@@ -44,7 +44,6 @@ describe('TreeMultiset operations test', () => {
     const lesserSum = treeMultiset.lesserSum(10);
     expect(lesserSum).toBe(45);
 
-
     expect(node15 instanceof TreeMultisetNode);
     if (node15 instanceof TreeMultisetNode) {
       const subTreeAdd = treeMultiset.subTreeAddCount(15, 1);
@@ -204,17 +203,31 @@ describe('TreeMultiset operations test', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objTreeMultiset = new TreeMultiset<TreeMultisetNode<{ id: number, keyA: number }>>();
+    const objTreeMultiset = new TreeMultiset<TreeMultisetNode<{id: number; keyA: number}>>();
     expect(objTreeMultiset).toBeInstanceOf(TreeMultiset);
     objTreeMultiset.add(11, {id: 11, keyA: 11});
     objTreeMultiset.add(3, {id: 3, keyA: 3});
-    const values = [{id: 15, keyA: 15}, {id: 1, keyA: 1}, {id: 8, keyA: 8},
-      {id: 13, keyA: 13}, {id: 16, keyA: 16}, {id: 2, keyA: 2},
-      {id: 6, keyA: 6}, {id: 9, keyA: 9}, {id: 12, keyA: 12},
-      {id: 14, keyA: 14}, {id: 4, keyA: 4}, {id: 7, keyA: 7},
-      {id: 10, keyA: 10}, {id: 5, keyA: 5}];
-
-    objTreeMultiset.addMany(values.map(item => item.id), values);
+    const values = [
+      {id: 15, keyA: 15},
+      {id: 1, keyA: 1},
+      {id: 8, keyA: 8},
+      {id: 13, keyA: 13},
+      {id: 16, keyA: 16},
+      {id: 2, keyA: 2},
+      {id: 6, keyA: 6},
+      {id: 9, keyA: 9},
+      {id: 12, keyA: 12},
+      {id: 14, keyA: 14},
+      {id: 4, keyA: 4},
+      {id: 7, keyA: 7},
+      {id: 10, keyA: 10},
+      {id: 5, keyA: 5}
+    ];
+
+    objTreeMultiset.addMany(
+      values.map(item => item.id),
+      values
+    );
 
     expect(objTreeMultiset.root).toBeInstanceOf(TreeMultisetNode);
 
@@ -414,7 +427,6 @@ describe('TreeMultiset Performance test', function () {
   // }
 
   it(`Observe the time consumption of TreeMultiset.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
@@ -446,5 +458,4 @@ describe('TreeMultiset Performance test', function () {
     //   })
     //   .run({async: true});
   });
-
 });

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

@@ -7,7 +7,6 @@ describe('DirectedGraph Operation Test', () => {
     graph = new DirectedGraph();
   });
 
-
   it('should add vertices', () => {
     const vertex1 = new DirectedVertex('A');
     const vertex2 = new DirectedVertex('B');
@@ -64,7 +63,6 @@ describe('DirectedGraph Operation Test', () => {
 });
 
 class MyVertex<V extends string> extends DirectedVertex<V> {
-
   constructor(id: VertexId, val?: V) {
     super(id, val);
     this._data = val;
@@ -82,7 +80,6 @@ class MyVertex<V extends string> extends DirectedVertex<V> {
 }
 
 class MyEdge<E extends string> extends DirectedEdge<E> {
-
   constructor(v1: VertexId, v2: VertexId, weight?: number, val?: E) {
     super(v1, v2, weight, val);
     this._data = val;
@@ -125,7 +122,6 @@ describe('Inherit from DirectedGraph and perform operations', () => {
     myGraph.addVertex(new MyVertex(7, 'data7'));
     myGraph.addVertex(new MyVertex(8, 'data8'));
     myGraph.addVertex(new MyVertex(9, 'data9'));
-
   });
 
   it('Add edges', () => {
@@ -157,13 +153,10 @@ describe('Inherit from DirectedGraph and perform operations', () => {
       expect(edge1).toEqual(edge2);
       expect(edge3).toBeNull();
     }
-
   });
 
   it('Edge set and vertex set', () => {
-    const edges = myGraph.edgeSet();
-    const vertices = myGraph.vertices;
-
+    expect(true).toBeTruthy();
   });
 
   it('Remove edge between vertices', () => {
@@ -177,13 +170,12 @@ describe('Inherit from DirectedGraph and perform operations', () => {
     expect(removedEdge).toBeInstanceOf(MyEdge);
     if (removedEdge) {
       removedEdge && expect(removedEdge.val).toBe('edge-data1-2');
-      removedEdge && expect(removedEdge.src).toBe(1)
+      removedEdge && expect(removedEdge.src).toBe(1);
     }
     expect(edgeAfterRemoval).toBeNull();
   });
 
   it('Topological sort', () => {
-
     const sorted = myGraph.topologicalSort();
 
     expect(sorted).toBeInstanceOf(Array);
@@ -193,15 +185,12 @@ describe('Inherit from DirectedGraph and perform operations', () => {
       sorted[3] instanceof MyVertex && expect(sorted[3].data).toBe('data6');
       sorted[8] instanceof MyVertex && expect(sorted[8].id).toBe(1);
     }
-
   });
 
   it('Minimum path between vertices', () => {
     myGraph.addVertex(new MyVertex(1, 'data1'));
     myGraph.addVertex(new MyVertex(2, 'data2'));
     myGraph.addEdge(new MyEdge(1, 2, 10, 'edge-data1-2'));
-
-    const minPath = myGraph.getMinPathBetween(1, 2);
   });
 
   it('All paths between vertices', () => {
@@ -210,8 +199,6 @@ describe('Inherit from DirectedGraph and perform operations', () => {
     myGraph.addVertex(new MyVertex(2, 'data2'));
     myGraph.addEdge(new MyEdge(1, 2, 10, 'edge-data1-2'));
 
-    const allPaths = myGraph.getAllPathsBetween(1, 2);
-
     // Add expect statements here to verify the allPaths
   });
 });
@@ -308,7 +295,6 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
     expect(min).toBe(Infinity);
     expect(minPath).toBeInstanceOf(Array);
 
-
     const floydResult = myGraph.floyd();
     expect(floydResult).toBeTruthy();
     if (floydResult) {
@@ -320,9 +306,29 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
       expect(costs[2]).toEqual([3, 15, 38, 17, 35, Infinity, 64, Infinity, 22]);
       expect(costs[3]).toEqual([123, 135, 120, 137, 155, Infinity, 47, Infinity, 126]);
       expect(costs[4]).toEqual([133, 145, 130, 147, 165, Infinity, 57, Infinity, 136]);
-      expect(costs[5]).toEqual([Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity]);
+      expect(costs[5]).toEqual([
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity
+      ]);
       expect(costs[6]).toEqual([76, 88, 73, 90, 108, Infinity, 137, Infinity, 79]);
-      expect(costs[7]).toEqual([Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity]);
+      expect(costs[7]).toEqual([
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity
+      ]);
       expect(costs[8]).toEqual([173, 185, 170, 187, 205, Infinity, 97, Infinity, 176]);
 
       expect(predecessor).toBeInstanceOf(Array);
@@ -338,7 +344,7 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
 
     expect(dijkstraRes12tt).toBeTruthy();
     if (dijkstraRes12tt) {
-      const {distMap, minDist, minPath, paths, preMap, seen} = dijkstraRes12tt;
+      const {distMap, minDist, minPath, paths} = dijkstraRes12tt;
       expect(distMap).toBeInstanceOf(Map);
       expect(distMap.size).toBe(9);
       expect(distMap.get(vertex1)).toBe(0);
@@ -383,14 +389,13 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
       expect(paths[8]).toBeInstanceOf(Array);
       expect(paths[8][0]).toBe(vertex1);
       expect(paths[8][1]).toBe(vertex9);
-
     }
 
     const dijkstraRes1ntt = myGraph.dijkstra(1, null, true, true);
 
     expect(dijkstraRes1ntt).toBeTruthy();
     if (dijkstraRes1ntt) {
-      const {distMap, minDist, minPath, paths, preMap, seen} = dijkstraRes1ntt;
+      const {distMap, minDist, minPath, paths} = dijkstraRes1ntt;
       expect(distMap).toBeInstanceOf(Map);
       expect(distMap.size).toBe(9);
       expect(distMap.get(vertex1)).toBe(0);
@@ -447,13 +452,12 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
       expect(paths[8]).toBeInstanceOf(Array);
       expect(paths[8][0]).toBe(vertex1);
       expect(paths[8][1]).toBe(vertex9);
-
     }
 
     const dijkstraWithoutHeapRes1ntt = myGraph.dijkstraWithoutHeap(1, null, true, true);
     expect(dijkstraWithoutHeapRes1ntt).toBeTruthy();
     if (dijkstraWithoutHeapRes1ntt) {
-      const {distMap, minDist, minPath, paths, preMap, seen} = dijkstraWithoutHeapRes1ntt;
+      const {distMap, minDist, minPath, paths} = dijkstraWithoutHeapRes1ntt;
       expect(distMap).toBeInstanceOf(Map);
       expect(distMap.size).toBe(9);
       expect(distMap.get(vertex1)).toBe(0);
@@ -510,8 +514,6 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
       expect(paths[8]).toBeInstanceOf(Array);
       expect(paths[8][0]).toBe(vertex1);
       expect(paths[8][1]).toBe(vertex9);
-
     }
   });
 });
-

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

@@ -5,13 +5,13 @@ describe('MapGraph Operation Test', () => {
     const mapGraph = new MapGraph([5.500338, 100.173665]);
 
     mapGraph.addVertex(new MapVertex('Surin', 5.466724, 100.274805));
-    mapGraph.addVertex(new MapVertex('Batu Feringgi Beach', 5.475141, 100.276670));
+    mapGraph.addVertex(new MapVertex('Batu Feringgi Beach', 5.475141, 100.27667));
     mapGraph.addVertex(new MapVertex('Lotus', 5.459044, 100.308767));
     mapGraph.addVertex(new MapVertex('The Breeza', 5.454197, 100.307859));
-    mapGraph.addVertex(new MapVertex('Hard Rock Hotel', 5.467850, 100.241876));
-    mapGraph.addVertex(new MapVertex('Mira', 5.456749, 100.286650));
+    mapGraph.addVertex(new MapVertex('Hard Rock Hotel', 5.46785, 100.241876));
+    mapGraph.addVertex(new MapVertex('Mira', 5.456749, 100.28665));
     mapGraph.addVertex(new MapVertex('Penang Bible Church', 5.428683, 100.314825));
-    mapGraph.addVertex(new MapVertex('Queensbay', 5.332760, 100.306651));
+    mapGraph.addVertex(new MapVertex('Queensbay', 5.33276, 100.306651));
     mapGraph.addVertex(new MapVertex('Saanen Goat Farm', 5.405738, 100.207699));
     mapGraph.addVertex(new MapVertex('Trinity Auto', 5.401126, 100.303739));
     mapGraph.addVertex(new MapVertex('Penang Airport', 5.293185, 100.265772));
@@ -42,5 +42,4 @@ describe('MapGraph Operation Test', () => {
     expect(surinToSaanenGoatFarmViaDij?.minPath.map(v => v.id)).toEqual(expected2);
     expect(surinToSaanenGoatFarmViaDij?.minDist).toBe(25.2);
   });
-
 });

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

@@ -1,19 +1,18 @@
 import {DirectedGraph, UndirectedGraph} from '../../../../src';
 
 describe('Overall Graph Operation Test', () => {
-
   it('Overall DirectedGraph Operation Test', () => {
     const graph = new DirectedGraph();
 
     graph.addVertex('A');
     graph.addVertex('B');
 
-    graph.hasVertex('A');       // true
-    graph.hasVertex('B');       // true
-    graph.hasVertex('C');       // false
-    expect(graph.hasVertex('A')).toBe(true);       // true
-    expect(graph.hasVertex('B')).toBe(true);       // true
-    expect(graph.hasVertex('C')).toBe(false);       // false
+    graph.hasVertex('A'); // true
+    graph.hasVertex('B'); // true
+    graph.hasVertex('C'); // false
+    expect(graph.hasVertex('A')).toBe(true); // true
+    expect(graph.hasVertex('B')).toBe(true); // true
+    expect(graph.hasVertex('C')).toBe(false); // false
 
     graph.addEdge('A', 'B');
     graph.hasEdge('A', 'B'); // true
@@ -22,8 +21,8 @@ describe('Overall Graph Operation Test', () => {
     expect(graph.hasEdge('B', 'A')).toBe(false); // false
 
     graph.removeEdgeSrcToDest('A', 'B');
-    graph.hasEdge('A', 'B');    // false
-    expect(graph.hasEdge('A', 'B')).toBe(false);    // false
+    graph.hasEdge('A', 'B'); // false
+    expect(graph.hasEdge('A', 'B')).toBe(false); // false
 
     graph.addVertex('C');
 
@@ -31,7 +30,7 @@ describe('Overall Graph Operation Test', () => {
     graph.addEdge('B', 'C');
 
     const topologicalOrderIds = graph.topologicalSort();
-    expect(topologicalOrderIds).toEqual(['A', 'B', 'C'])
+    expect(topologicalOrderIds).toEqual(['A', 'B', 'C']);
   });
   it('Overall UndirectedGraph Operation Test', () => {
     const graph = new UndirectedGraph();
@@ -44,7 +43,7 @@ describe('Overall Graph Operation Test', () => {
     graph.addEdge('B', 'D');
 
     const dijkstraResult = graph.dijkstra('A');
-    Array.from(dijkstraResult?.seen ?? []).map(vertex => vertex.id) // ['A', 'B', 'D']
+    Array.from(dijkstraResult?.seen ?? []).map(vertex => vertex.id); // ['A', 'B', 'D']
     expect(Array.from(dijkstraResult?.seen ?? []).map(vertex => vertex.id)).toEqual(['A', 'B', 'D']);
   });
 });

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

@@ -7,7 +7,6 @@ describe('UndirectedGraph Operation Test', () => {
     graph = new UndirectedGraph();
   });
 
-
   it('should add vertices', () => {
     const vertex1 = new UndirectedVertex('A');
     const vertex2 = new UndirectedVertex('B');

package/test/unit/data-structures/hash/coordinate-map.test.ts

@@ -0,0 +1,54 @@
+import {CoordinateMap} from '../../../../src';
+
+describe('CoordinateMap', () => {
+  it('should set and get values correctly', () => {
+    const coordinateMap = new CoordinateMap<string>();
+    const key = [1, 2, 3];
+    const value = 'TestValue';
+
+    coordinateMap.set(key, value);
+    const retrievedValue = coordinateMap.get(key);
+
+    expect(retrievedValue).toBe(value);
+  });
+
+  it('should return true when key exists', () => {
+    const coordinateMap = new CoordinateMap<string>();
+    const key = [1, 2, 3];
+    const value = 'TestValue';
+
+    coordinateMap.set(key, value);
+
+    expect(coordinateMap.has(key)).toBe(true);
+  });
+
+  it('should return false when key does not exist', () => {
+    const coordinateMap = new CoordinateMap<string>();
+    const key = [1, 2, 3];
+
+    expect(coordinateMap.has(key)).toBe(false);
+  });
+
+  it('should delete key-value pair correctly', () => {
+    const coordinateMap = new CoordinateMap<string>();
+    const key = [1, 2, 3];
+    const value = 'TestValue';
+
+    coordinateMap.set(key, value);
+    coordinateMap.delete(key);
+
+    expect(coordinateMap.has(key)).toBe(false);
+  });
+
+  it('should allow changing the joint character', () => {
+    const coordinateMap = new CoordinateMap<string>();
+    const key = [1, 2, 3];
+    const value = 'TestValue';
+
+    coordinateMap.set(key, value);
+    const newKey = [1, 2, 3];
+    const retrievedValue = coordinateMap.get(newKey);
+
+    expect(retrievedValue).toBe(value);
+  });
+});

package/test/unit/data-structures/hash/coordinate-set.test.ts

@@ -0,0 +1,41 @@
+import {CoordinateSet} from '../../../../src';
+
+describe('CoordinateSet', () => {
+  it('should add and check values correctly', () => {
+    const coordinateSet = new CoordinateSet();
+    const value = [1, 2, 3];
+
+    coordinateSet.add(value);
+    const hasValue = coordinateSet.has(value);
+
+    expect(hasValue).toBe(true);
+  });
+
+  it('should return false when value does not exist', () => {
+    const coordinateSet = new CoordinateSet();
+    const value = [1, 2, 3];
+
+    expect(coordinateSet.has(value)).toBe(false);
+  });
+
+  it('should delete value correctly', () => {
+    const coordinateSet = new CoordinateSet();
+    const value = [1, 2, 3];
+
+    coordinateSet.add(value);
+    coordinateSet.delete(value);
+
+    expect(coordinateSet.has(value)).toBe(false);
+  });
+
+  it('should allow changing the joint character', () => {
+    const coordinateSet = new CoordinateSet();
+    const value = [1, 2, 3];
+
+    coordinateSet.add(value);
+    const newValue = [1, 2, 3];
+    const hasValue = coordinateSet.has(newValue);
+
+    expect(hasValue).toBe(true);
+  });
+});

package/test/unit/data-structures/hash/hash-table.test.ts

@@ -0,0 +1,97 @@
+import {HashNode, HashTable} from '../../../../src';
+
+describe('HashNode', () => {
+  it('should create a HashNode with key and value', () => {
+    const key = 'testKey';
+    const value = 'testValue';
+    const hashNode = new HashNode(key, value);
+
+    expect(hashNode.key).toBe(key);
+    expect(hashNode.val).toBe(value);
+    expect(hashNode.next).toBe(null);
+  });
+});
+
+describe('HashTable', () => {
+  it('should initialize with default capacity', () => {
+    const hashTable = new HashTable<string, string>();
+
+    expect(hashTable.capacity).toBe(1000);
+    expect(hashTable.size).toBe(0);
+    expect(hashTable.buckets.length).toBe(1000);
+  });
+
+  it('should initialize with custom capacity', () => {
+    const customCapacity = 500;
+    const hashTable = new HashTable<string, string>(customCapacity);
+
+    expect(hashTable.capacity).toBe(customCapacity);
+    expect(hashTable.size).toBe(0);
+    expect(hashTable.buckets.length).toBe(customCapacity);
+  });
+
+  it('should put and get values correctly', () => {
+    const hashTable = new HashTable<string, string>();
+    const key = 'testKey';
+    const value = 'testValue';
+
+    hashTable.put(key, value);
+    const retrievedValue = hashTable.get(key);
+
+    expect(retrievedValue).toBe(value);
+  });
+
+  it('should handle collisions by chaining', () => {
+    const hashTable = new HashTable<string, string>();
+    const key1 = 'testKey1';
+    const value1 = 'testValue1';
+    const key2 = 'testKey2';
+    const value2 = 'testValue2';
+
+    hashTable.put(key1, value1);
+    hashTable.put(key2, value2);
+
+    const retrievedValue1 = hashTable.get(key1);
+    const retrievedValue2 = hashTable.get(key2);
+
+    expect(retrievedValue1).toBe(value1);
+    expect(retrievedValue2).toBe(value2);
+  });
+
+  it('should update value for an existing key', () => {
+    const hashTable = new HashTable<string, string>();
+    const key = 'testKey';
+    const initialValue = 'testValue1';
+    const updatedValue = 'testValue2';
+
+    hashTable.put(key, initialValue);
+    hashTable.put(key, updatedValue);
+
+    const retrievedValue = hashTable.get(key);
+
+    expect(retrievedValue).toBe(updatedValue);
+  });
+
+  it('should return undefined for non-existent key', () => {
+    const hashTable = new HashTable<string, string>();
+    const key = 'nonExistentKey';
+
+    const retrievedValue = hashTable.get(key);
+
+    expect(retrievedValue).toBeUndefined();
+  });
+
+  it('should remove key-value pair correctly', () => {
+    const hashTable = new HashTable<string, string>();
+    const key = 'testKey';
+    const value = 'testValue';
+
+    hashTable.put(key, value);
+    hashTable.remove(key);
+
+    const retrievedValue = hashTable.get(key);
+
+    expect(retrievedValue).toBeUndefined();
+    expect(hashTable.size).toBe(0);
+  });
+});

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

@@ -21,31 +21,31 @@ describe('Heap Operation Test', () => {
   });
 
   it('should object heap work well', function () {
-    const minHeap = new MinHeap<{ a: string }>();
+    const minHeap = new MinHeap<{a: string}>();
     minHeap.add(1, {a: 'a1'});
     minHeap.add(6, {a: 'a6'});
     minHeap.add(2, {a: 'a2'});
     minHeap.add(0, {a: 'a0'});
 
     expect(minHeap.peek()).toEqual({a: 'a0'});
-    expect(minHeap.toArray()).toEqual(([{'a': 'a0'}, {'a': 'a1'}, {'a': 'a2'}, {'a': 'a6'}]));
+    expect(minHeap.toArray()).toEqual([{a: 'a0'}, {a: 'a1'}, {a: 'a2'}, {a: 'a6'}]);
     let i = 0;
-    const expectPolled = [{'a': 'a0'}, {'a': 'a1'}, {'a': 'a2'}, {'a': 'a6'}];
+    const expectPolled = [{a: 'a0'}, {a: 'a1'}, {a: 'a2'}, {a: 'a6'}];
     while (minHeap.size > 0) {
       expect(minHeap.poll()).toEqual(expectPolled[i]);
       i++;
     }
 
-    const maxHeap = new MaxHeap<{ a: string }>();
+    const maxHeap = new MaxHeap<{a: string}>();
     maxHeap.add(1, {a: 'a1'});
     maxHeap.add(6, {a: 'a6'});
     maxHeap.add(5, {a: 'a5'});
     maxHeap.add(2, {a: 'a2'});
     maxHeap.add(0, {a: 'a0'});
     maxHeap.add(9, {a: 'a9'});
-    expect(maxHeap.peek()).toEqual({'a': 'a9'});
-    expect(maxHeap.toArray()).toEqual([{'a': 'a9'}, {'a': 'a2'}, {'a': 'a6'}, {'a': 'a1'}, {'a': 'a0'}, {'a': 'a5'}]);
-    const maxExpectPolled = [{'a': 'a9'}, {'a': 'a6'}, {'a': 'a5'}, {'a': 'a2'}, {'a': 'a1'}, {'a': 'a0'}];
+    expect(maxHeap.peek()).toEqual({a: 'a9'});
+    expect(maxHeap.toArray()).toEqual([{a: 'a9'}, {a: 'a2'}, {a: 'a6'}, {a: 'a1'}, {a: 'a0'}, {a: 'a5'}]);
+    const maxExpectPolled = [{a: 'a9'}, {a: 'a6'}, {a: 'a5'}, {a: 'a2'}, {a: 'a1'}, {a: 'a0'}];
     let maxI = 0;
     while (maxHeap.size > 0) {
       expect(maxHeap.poll()).toEqual(maxExpectPolled[maxI]);
@@ -53,4 +53,3 @@ describe('Heap Operation Test', () => {
     }
   });
 });
-

package/test/unit/data-structures/heap/max-heap.test.ts

@@ -1,11 +1,14 @@
 import {HeapItem, MaxHeap} from '../../../../src';
 
 describe('MaxHeap Operation Test', () => {
-
   it('should object Max Heap operations be proper', function () {
-    const maxHeap = new MaxHeap<{ keyA: string }>();
-    const myObj1 = {keyA: 'a1'}, myObj6 = {keyA: 'a6'}, myObj5 = {keyA: 'a5'}, myObj2 = {keyA: 'a2'},
-      myObj0 = {keyA: 'a0'}, myObj9 = {keyA: 'a9'};
+    const maxHeap = new MaxHeap<{keyA: string}>();
+    const myObj1 = {keyA: 'a1'},
+      myObj6 = {keyA: 'a6'},
+      myObj5 = {keyA: 'a5'},
+      myObj2 = {keyA: 'a2'},
+      myObj0 = {keyA: 'a0'},
+      myObj9 = {keyA: 'a9'};
     maxHeap.add(1, myObj1);
     expect(maxHeap.has(myObj1)).toBe(true);
     expect(maxHeap.has(myObj9)).toBe(false);
@@ -38,5 +41,4 @@ describe('MaxHeap Operation Test', () => {
       i++;
     }
   });
-
 });

package/test/unit/data-structures/heap/min-heap.test.ts

@@ -1,7 +1,6 @@
 import {HeapItem, MinHeap} from '../../../../src';
 
 describe('MinHeap Operation Test', () => {
-
   it('should numeric Min Heap operations be proper', function () {
     const minNumHeap = new MinHeap<number>();
     expect(minNumHeap).toBeInstanceOf(MinHeap);
@@ -22,15 +21,15 @@ describe('MinHeap Operation Test', () => {
     expect(minNumHeap.size).toBe(6);
 
     const poll1 = minNumHeap.poll(true);
-    expect(poll1).toBeInstanceOf(HeapItem)
+    expect(poll1).toBeInstanceOf(HeapItem);
     poll1 instanceof HeapItem && expect(poll1.val).toBe(0);
 
     const poll2 = minNumHeap.poll(true);
-    expect(poll2).toBeInstanceOf(HeapItem)
+    expect(poll2).toBeInstanceOf(HeapItem);
     poll2 instanceof HeapItem && expect(poll2.val).toBe(1);
 
     const peek1 = minNumHeap.peek(true);
-    expect(peek1).toBeInstanceOf(HeapItem)
+    expect(peek1).toBeInstanceOf(HeapItem);
     peek1 instanceof HeapItem && expect(peek1.val).toBe(2);
 
     const heapArray = minNumHeap.toArray(true);
@@ -50,7 +49,9 @@ describe('MinHeap Operation Test', () => {
 
     const minObjHeap = new MinHeap<MyObject>();
 
-    const obj1 = new MyObject('a1'), obj6 = new MyObject('a6'), obj2 = new MyObject('a2'),
+    const obj1 = new MyObject('a1'),
+      obj6 = new MyObject('a6'),
+      obj2 = new MyObject('a2'),
       obj0 = new MyObject('a0');
     minObjHeap.add(1, obj1);
     expect(minObjHeap.has(obj1)).toBe(true);