data-structure-typed 1.38.9 → 1.39.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.38.9",
+  "version": "1.39.0",
   "description": "Data Structures of Javascript & TypeScript. Binary Tree, BST, Graph, Heap, Priority Queue, Linked List, Queue, Deque, Stack, AVL Tree, Tree Multiset, Trie, Directed Graph, Undirected Graph, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue.",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
@@ -61,17 +61,17 @@
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
     "auto-changelog": "^2.4.0",
-    "avl-tree-typed": "^1.38.8",
+    "avl-tree-typed": "^1.38.9",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.38.8",
-    "bst-typed": "^1.38.8",
+    "binary-tree-typed": "^1.38.9",
+    "bst-typed": "^1.38.9",
     "dependency-cruiser": "^14.1.0",
     "eslint": "^8.50.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-import-resolver-alias": "^1.1.2",
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-import": "^2.28.1",
-    "heap-typed": "^1.38.8",
+    "heap-typed": "^1.38.9",
     "istanbul-badges-readme": "^1.8.5",
     "jest": "^29.7.0",
     "prettier": "^3.0.3",

package/src/data-structures/binary-tree/binary-indexed-tree.ts

@@ -143,6 +143,26 @@ export class BinaryIndexedTree {
     return this._binarySearch(sum, (x, y) => x <= y);
   }
 
+  /**
+   * The function calculates the prefix sum of an array using a binary indexed tree.
+   * @param {number} i - The parameter "i" in the function "getPrefixSum" represents the index of the element in the
+   * array for which we want to calculate the prefix sum.
+   * @returns The function `getPrefixSum` returns the prefix sum of the elements in the binary indexed tree up to index
+   * `i`.
+   */
+  getPrefixSum(i: number): number {
+    this._checkIndex(i);
+    i++; // Convert to 1-based index
+
+    let sum = 0;
+    while (i > 0) {
+      sum += this._getFrequency(i);
+      i -= i & -i;
+    }
+
+    return sum;
+  }
+
   /**
    * The function returns the value of a specific index in a freqMap data structure, or a default value if
    * the index is not found.

package/src/data-structures/graph/abstract-graph.ts

@@ -130,7 +130,7 @@ export abstract class AbstractGraph<
    */
   abstract createEdge(srcOrV1: VertexKey | string, destOrV2: VertexKey | string, weight?: number, val?: E): E;
 
-  abstract removeEdge(edge: E): E | null;
+  abstract deleteEdge(edge: E): E | null;
 
   abstract getEdge(srcOrKey: V | VertexKey, destOrKey: V | VertexKey): E | null;
 
@@ -179,12 +179,12 @@ export abstract class AbstractGraph<
   }
 
   /**
-   * The `removeVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
+   * The `deleteVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
    * @param {V | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`V`) or a vertex ID
    * (`VertexKey`).
    * @returns The method is returning a boolean value.
    */
-  removeVertex(vertexOrKey: V | VertexKey): boolean {
+  deleteVertex(vertexOrKey: V | VertexKey): boolean {
     const vertexKey = this._getVertexKey(vertexOrKey);
     return this._vertices.delete(vertexKey);
   }
@@ -199,7 +199,7 @@ export abstract class AbstractGraph<
   removeAllVertices(vertices: V[] | VertexKey[]): boolean {
     const removed: boolean[] = [];
     for (const v of vertices) {
-      removed.push(this.removeVertex(v));
+      removed.push(this.deleteVertex(v));
     }
     return removed.length > 0;
   }
@@ -622,7 +622,7 @@ export abstract class AbstractGraph<
       if (vertexOrKey instanceof AbstractVertex) distMap.set(vertexOrKey, Infinity);
     }
 
-    const heap = new PriorityQueue<{ key: number; val: V }>((a, b) => a.key - b.key);
+    const heap = new PriorityQueue<{ key: number; val: V }>({comparator: (a, b) => a.key - b.key});
     heap.add({key: 0, val: srcVertex});
 
     distMap.set(srcVertex, 0);

package/src/data-structures/graph/directed-graph.ts

@@ -153,7 +153,7 @@ export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E ext
    * @param {V | VertexKey} destOrKey - The `destOrKey` parameter represents the destination vertex or its ID.
    * @returns the removed edge (E) if it exists, or null if either the source or destination vertex does not exist.
    */
-  removeEdgeSrcToDest(srcOrKey: V | VertexKey, destOrKey: V | VertexKey): E | null {
+  deleteEdgeSrcToDest(srcOrKey: V | VertexKey, destOrKey: V | VertexKey): E | null {
     const src: V | null = this._getVertex(srcOrKey);
     const dest: V | null = this._getVertex(destOrKey);
     let removed: E | null = null;
@@ -177,9 +177,9 @@ export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E ext
    * The function removes an edge from a graph and returns the removed edge, or null if the edge was not found.
    * @param {E} edge - The `edge` parameter is an object that represents an edge in a graph. It has two properties: `src`
    * and `dest`, which represent the source and destination vertices of the edge, respectively.
-   * @returns The method `removeEdge` returns the removed edge (`E`) if it exists, or `null` if the edge does not exist.
+   * @returns The method `deleteEdge` returns the removed edge (`E`) if it exists, or `null` if the edge does not exist.
    */
-  removeEdge(edge: E): E | null {
+  deleteEdge(edge: E): E | null {
     let removed: E | null = null;
     const src = this._getVertex(edge.src);
     const dest = this._getVertex(edge.dest);
@@ -206,12 +206,12 @@ export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E ext
    * the second vertex in the edge that needs to be removed.
    * @returns an array of removed edges (E[]).
    */
-  removeEdgesBetween(v1: VertexKey | V, v2: VertexKey | V): E[] {
+  deleteEdgesBetween(v1: VertexKey | V, v2: VertexKey | V): E[] {
     const removed: E[] = [];
 
     if (v1 && v2) {
-      const v1ToV2 = this.removeEdgeSrcToDest(v1, v2);
-      const v2ToV1 = this.removeEdgeSrcToDest(v2, v1);
+      const v1ToV2 = this.deleteEdgeSrcToDest(v1, v2);
+      const v2ToV1 = this.deleteEdgeSrcToDest(v2, v1);
 
       v1ToV2 && removed.push(v1ToV2);
       v2ToV1 && removed.push(v2ToV1);

package/src/data-structures/graph/undirected-graph.ts

@@ -127,7 +127,7 @@ export class UndirectedGraph<
    * (VertexKey). It represents the second vertex of the edge that needs to be removed.
    * @returns the removed edge (E) if it exists, or null if either of the vertices (V) does not exist.
    */
-  removeEdgeBetween(v1: V | VertexKey, v2: V | VertexKey): E | null {
+  deleteEdgeBetween(v1: V | VertexKey, v2: V | VertexKey): E | null {
     const vertex1: V | null = this._getVertex(v1);
     const vertex2: V | null = this._getVertex(v2);
 
@@ -148,12 +148,12 @@ export class UndirectedGraph<
   }
 
   /**
-   * The removeEdge function removes an edge between two vertices in a graph.
+   * The deleteEdge function removes an edge between two vertices in a graph.
    * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
    * @returns The method is returning either the removed edge (of type E) or null if the edge was not found.
    */
-  removeEdge(edge: E): E | null {
-    return this.removeEdgeBetween(edge.vertices[0], edge.vertices[1]);
+  deleteEdge(edge: E): E | null {
+    return this.deleteEdgeBetween(edge.vertices[0], edge.vertices[1]);
   }
 
   /**

package/src/data-structures/heap/heap.ts

@@ -7,12 +7,16 @@
 
 import type {Comparator, DFSOrderPattern} from '../../types';
 
-export class Heap<E> {
+export class Heap<E = any> {
   protected nodes: E[] = [];
   protected readonly comparator: Comparator<E>;
 
-  constructor(comparator: Comparator<E>) {
-    this.comparator = comparator;
+  constructor(options: { comparator: Comparator<E>; nodes?: E[] }) {
+    this.comparator = options.comparator;
+    if (options.nodes && options.nodes.length > 0) {
+      this.nodes = options.nodes;
+      this.fix();
+    }
   }
 
   /**
@@ -32,15 +36,11 @@ export class Heap<E> {
 
   /**
    * Static method that creates a binary heap from an array of nodes and a comparison function.
-   * @param nodes
-   * @param comparator - Comparison function.
    * @returns A new Heap instance.
+   * @param options
    */
-  static heapify<E>(nodes: E[], comparator: Comparator<E>): Heap<E> {
-    const binaryHeap = new Heap<E>(comparator);
-    binaryHeap.nodes = [...nodes];
-    binaryHeap.fix(); // Fix heap properties
-    return binaryHeap;
+  static heapify<E>(options: { nodes: E[]; comparator: Comparator<E> }): Heap<E> {
+    return new Heap<E>(options);
   }
 
   /**
@@ -180,7 +180,7 @@ export class Heap<E> {
    * @returns A new Heap instance containing the same elements.
    */
   clone(): Heap<E> {
-    const clonedHeap = new Heap<E>(this.comparator);
+    const clonedHeap = new Heap<E>({comparator: this.comparator});
     clonedHeap.nodes = [...this.nodes];
     return clonedHeap;
   }
@@ -269,7 +269,7 @@ export class FibonacciHeapNode<E> {
 
 export class FibonacciHeap<E> {
   root?: FibonacciHeapNode<E>;
-  size: number = 0;
+  size = 0;
   protected min?: FibonacciHeapNode<E>;
   protected readonly comparator: Comparator<E>;
 

package/src/data-structures/heap/max-heap.ts

@@ -11,14 +11,16 @@ import type {Comparator} from '../../types';
 
 export class MaxHeap<E = any> extends Heap<E> {
   constructor(
-    comparator: Comparator<E> = (a: E, b: E) => {
-      if (!(typeof a === 'number' && typeof b === 'number')) {
-        throw new Error('The a, b params of compare function must be number');
-      } else {
-        return b - a;
+    options: { comparator: Comparator<E>; nodes?: E[] } = {
+      comparator: (a: E, b: E) => {
+        if (!(typeof a === 'number' && typeof b === 'number')) {
+          throw new Error('The a, b params of compare function must be number');
+        } else {
+          return b - a;
+        }
       }
     }
   ) {
-    super(comparator);
+    super(options);
   }
 }

package/src/data-structures/heap/min-heap.ts

@@ -11,14 +11,16 @@ import type {Comparator} from '../../types';
 
 export class MinHeap<E = any> extends Heap<E> {
   constructor(
-    comparator: Comparator<E> = (a: E, b: E) => {
-      if (!(typeof a === 'number' && typeof b === 'number')) {
-        throw new Error('The a, b params of compare function must be number');
-      } else {
-        return a - b;
+    options: { comparator: Comparator<E>; nodes?: E[] } = {
+      comparator: (a: E, b: E) => {
+        if (!(typeof a === 'number' && typeof b === 'number')) {
+          throw new Error('The a, b params of compare function must be number');
+        } else {
+          return a - b;
+        }
       }
     }
   ) {
-    super(comparator);
+    super(options);
   }
 }

package/src/data-structures/priority-queue/max-priority-queue.ts

@@ -10,14 +10,16 @@ import type {Comparator} from '../../types';
 
 export class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    compare: Comparator<E> = (a: E, b: E) => {
-      if (!(typeof a === 'number' && typeof b === 'number')) {
-        throw new Error('The a, b params of compare function must be number');
-      } else {
-        return b - a;
+    options: { comparator: Comparator<E>; nodes?: E[] } = {
+      comparator: (a: E, b: E) => {
+        if (!(typeof a === 'number' && typeof b === 'number')) {
+          throw new Error('The a, b params of compare function must be number');
+        } else {
+          return b - a;
+        }
       }
     }
   ) {
-    super(compare);
+    super(options);
   }
 }

package/src/data-structures/priority-queue/min-priority-queue.ts

@@ -10,14 +10,16 @@ import type {Comparator} from '../../types';
 
 export class MinPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    compare: Comparator<E> = (a: E, b: E) => {
-      if (!(typeof a === 'number' && typeof b === 'number')) {
-        throw new Error('The a, b params of compare function must be number');
-      } else {
-        return a - b;
+    options: { comparator: Comparator<E>; nodes?: E[] } = {
+      comparator: (a: E, b: E) => {
+        if (!(typeof a === 'number' && typeof b === 'number')) {
+          throw new Error('The a, b params of compare function must be number');
+        } else {
+          return a - b;
+        }
       }
     }
   ) {
-    super(compare);
+    super(options);
   }
 }

package/src/data-structures/priority-queue/priority-queue.ts

@@ -9,8 +9,8 @@
 import {Heap} from '../heap';
 import {Comparator} from '../../types';
 
-export class PriorityQueue<E> extends Heap<E> {
-  constructor(comparator: Comparator<E>) {
-    super(comparator);
+export class PriorityQueue<E = any> extends Heap<E> {
+  constructor(options: { comparator: Comparator<E>; nodes?: E[] }) {
+    super(options);
   }
 }

package/test/integration/bst.test.ts

@@ -183,7 +183,7 @@ describe('Individual package BST operations test', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objBST = new BST<{key: number; keyA: number}>();
+    const objBST = new BST<{ key: number; keyA: number }>();
     expect(objBST).toBeInstanceOf(BST);
     objBST.add(11, {key: 11, keyA: 11});
     objBST.add(3, {key: 3, keyA: 3});

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

@@ -110,7 +110,7 @@ describe('AVL Tree Test', () => {
 });
 
 describe('AVLTree APIs test', () => {
-  const avl = new AVLTree<{id: number; text: string}>();
+  const avl = new AVLTree<{ id: number; text: string }>();
   beforeEach(() => {
     avl.clear();
   });

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

@@ -283,3 +283,38 @@ function loopLowerBoundTests(bit: BinaryIndexedTree, values: number[]) {
     }
   }
 }
+
+describe('', () => {
+  class NumArrayDC {
+    private _tree: BinaryIndexedTree;
+    private readonly _nums: number[];
+
+    constructor(nums: number[]) {
+      this._nums = nums;
+      this._tree = new BinaryIndexedTree({max: nums.length + 1});
+      for (let i = 0; i < nums.length; i++) {
+        this._tree.update(i + 1, nums[i]);
+      }
+    }
+
+    update(index: number, val: number): void {
+      this._tree.update(index + 1, val - this._nums[index]);
+      this._nums[index] = val;
+    }
+
+    sumRange(left: number, right: number): number {
+      return this._tree.getPrefixSum(right + 1) - this._tree.getPrefixSum(left);
+    }
+  }
+
+  it('', () => {
+    const numArray = new NumArrayDC([1, 3, 5, 8, 2, 9, 4, 5, 8, 1, 3, 2]);
+    expect(numArray.sumRange(0, 8)).toBe(45);
+    expect(numArray.sumRange(0, 2)).toBe(9);
+    numArray.update(1, 2);
+    expect(numArray.sumRange(0, 2)).toBe(8);
+    expect(numArray.sumRange(3, 4)).toBe(10);
+    numArray.update(3, 2);
+    expect(numArray.sumRange(3, 4)).toBe(4);
+  });
+});

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

@@ -200,7 +200,7 @@ describe('BinaryTree Morris Traversal', () => {
 });
 
 describe('BinaryTree APIs test', () => {
-  const avl = new AVLTree<{id: number; text: string}>();
+  const avl = new AVLTree<{ id: number; text: string }>();
   beforeEach(() => {
     avl.clear();
   });

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

@@ -189,7 +189,7 @@ describe('BST operations test', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objBST = new BST<{key: number; keyA: number}>();
+    const objBST = new BST<{ key: number; keyA: number }>();
     expect(objBST).toBeInstanceOf(BST);
     objBST.add(11, {key: 11, keyA: 11});
     objBST.add(3, {key: 3, keyA: 3});
@@ -260,7 +260,7 @@ describe('BST operations test', () => {
     objBST.perfectlyBalance();
     expect(objBST.isPerfectlyBalanced()).toBe(true);
 
-    const bfsNodesAfterBalanced: BSTNode<{key: number; keyA: number}>[] = [];
+    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);
@@ -385,7 +385,7 @@ describe('BST operations test', () => {
     expect(bfsIDs[1]).toBe(12);
     expect(bfsIDs[2]).toBe(16);
 
-    const bfsNodes: BSTNode<{key: number; keyA: number}>[] = [];
+    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);

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

@@ -29,7 +29,7 @@ describe('Overall BinaryTree Test', () => {
     bfsIDs[0] === 11; // true
     expect(bfsIDs[0]).toBe(11);
 
-    const objBST = new BST<{key: number; keyA: number}>();
+    const objBST = new BST<{ key: number; keyA: number }>();
     objBST.add(11, {key: 11, keyA: 11});
     objBST.add(3, {key: 3, keyA: 3});
 

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

@@ -206,7 +206,7 @@ describe('TreeMultiset operations test', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objTreeMultiset = new TreeMultiset<{key: number; keyA: number}>();
+    const objTreeMultiset = new TreeMultiset<{ key: number; keyA: number }>();
     expect(objTreeMultiset).toBeInstanceOf(TreeMultiset);
     objTreeMultiset.add(11, {key: 11, keyA: 11});
     objTreeMultiset.add(3, {key: 3, keyA: 3});

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

@@ -40,7 +40,7 @@ describe('DirectedGraph Operation Test', () => {
     graph.addVertex(vertex2);
     graph.addEdge(edge);
 
-    expect(graph.removeEdge(edge)).toBe(edge);
+    expect(graph.deleteEdge(edge)).toBe(edge);
     expect(graph.hasEdge('A', 'B')).toBe(false);
   });
 
@@ -164,7 +164,7 @@ describe('Inherit from DirectedGraph and perform operations', () => {
     myGraph.addVertex(2, 'data2');
     myGraph.addEdge(1, 2, 10, 'edge-data1-2');
 
-    const removedEdge = myGraph.removeEdgeSrcToDest(1, 2);
+    const removedEdge = myGraph.deleteEdgeSrcToDest(1, 2);
     const edgeAfterRemoval = myGraph.getEdge(1, 2);
 
     expect(removedEdge).toBeInstanceOf(MyEdge);
@@ -233,7 +233,7 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
     expect(myGraph.getEdge(2, 1)).toBeTruthy();
     expect(myGraph.getEdge(1, '100')).toBeFalsy();
 
-    myGraph.removeEdgeSrcToDest(1, 2);
+    myGraph.deleteEdgeSrcToDest(1, 2);
     expect(myGraph.getEdge(1, 2)).toBeFalsy();
 
     myGraph.addEdge(3, 1, 3, 'edge-data-3-1');

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

@@ -20,7 +20,7 @@ describe('Overall Graph Operation Test', () => {
     expect(graph.hasEdge('A', 'B')).toBe(true); // true
     expect(graph.hasEdge('B', 'A')).toBe(false); // false
 
-    graph.removeEdgeSrcToDest('A', 'B');
+    graph.deleteEdgeSrcToDest('A', 'B');
     graph.hasEdge('A', 'B'); // false
     expect(graph.hasEdge('A', 'B')).toBe(false); // false
 
@@ -38,7 +38,7 @@ describe('Overall Graph Operation Test', () => {
     graph.addVertex('B');
     graph.addVertex('C');
     graph.addVertex('D');
-    graph.removeVertex('C');
+    graph.deleteVertex('C');
     graph.addEdge('A', 'B');
     graph.addEdge('B', 'D');
 

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

@@ -40,7 +40,7 @@ describe('UndirectedGraph Operation Test', () => {
     graph.addVertex(vertex2);
     graph.addEdge(edge);
 
-    expect(graph.removeEdge(edge)).toBe(edge);
+    expect(graph.deleteEdge(edge)).toBe(edge);
     expect(graph.hasEdge('A', 'B')).toBe(false);
   });
 
@@ -49,7 +49,7 @@ describe('UndirectedGraph Operation Test', () => {
     graph.addVertex('B');
     graph.addVertex('C');
     graph.addVertex('D');
-    graph.removeVertex('C');
+    graph.deleteVertex('C');
     graph.addEdge('A', 'B');
     graph.addEdge('B', 'D');
 

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

@@ -22,7 +22,7 @@ describe('Heap Operation Test', () => {
   });
 
   it('should object heap work well', function () {
-    const minHeap = new MinHeap<{a: string; key: number}>((a, b) => a.key - b.key);
+    const minHeap = new MinHeap<{ a: string; key: number }>({comparator: (a, b) => a.key - b.key});
     minHeap.add({key: 1, a: 'a1'});
     minHeap.add({key: 6, a: 'a6'});
     minHeap.add({key: 2, a: 'a2'});
@@ -37,7 +37,7 @@ describe('Heap Operation Test', () => {
       i++;
     }
 
-    const maxHeap = new MaxHeap<{key: number; a: string}>((a, b) => b.key - a.key);
+    const maxHeap = new MaxHeap<{ key: number; a: string }>({comparator: (a, b) => b.key - a.key});
     maxHeap.add({key: 1, a: 'a1'});
     maxHeap.add({key: 6, a: 'a6'});
     maxHeap.add({key: 5, a: 'a5'});

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

@@ -5,7 +5,7 @@ describe('MaxHeap', () => {
   let maxHeap: MaxHeap<number>;
 
   beforeEach(() => {
-    maxHeap = new MaxHeap(numberComparator);
+    maxHeap = new MaxHeap({comparator: numberComparator});
   });
 
   test('add and poll elements in descending order', () => {

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

@@ -5,7 +5,7 @@ describe('MinHeap', () => {
   let minHeap: MinHeap<number>;
 
   beforeEach(() => {
-    minHeap = new MinHeap(numberComparator);
+    minHeap = new MinHeap({comparator: numberComparator});
   });
 
   test('add and poll elements in ascending order', () => {

package/test/unit/data-structures/linked-list/doubly-linked-list.test.ts

@@ -3,7 +3,7 @@ import {bigO, magnitude} from '../../../utils';
 
 describe('DoublyLinkedList Operation Test', () => {
   let list: DoublyLinkedList<number>;
-  let objectList: DoublyLinkedList<{keyA: number}>;
+  let objectList: DoublyLinkedList<{ keyA: number }>;
 
   beforeEach(() => {
     list = new DoublyLinkedList();

package/test/unit/data-structures/linked-list/singly-linked-list.test.ts

@@ -3,10 +3,10 @@ import {bigO, magnitude} from '../../../utils';
 
 describe('SinglyLinkedList Operation Test', () => {
   let list: SinglyLinkedList<number>;
-  let objectList: SinglyLinkedList<{keyA: number}>;
+  let objectList: SinglyLinkedList<{ keyA: number }>;
   beforeEach(() => {
     list = new SinglyLinkedList<number>();
-    objectList = new SinglyLinkedList<{keyA: number}>();
+    objectList = new SinglyLinkedList<{ keyA: number }>();
   });
 
   describe('push', () => {

package/test/unit/data-structures/priority-queue/max-priority-queue.test.ts

@@ -17,7 +17,7 @@ describe('MaxPriorityQueue Operation Test', () => {
   });
 
   it('should add elements and maintain heap property in a object MaxPriorityQueue', () => {
-    const priorityQueue = new MaxPriorityQueue<{keyA: number}>((a, b) => b.keyA - a.keyA);
+    const priorityQueue = new MaxPriorityQueue<{ keyA: number }>({comparator: (a, b) => b.keyA - a.keyA});
     priorityQueue.refill([{keyA: 5}, {keyA: 3}, {keyA: 1}]);
     priorityQueue.add({keyA: 7});
 
@@ -53,7 +53,7 @@ describe('MaxPriorityQueue Operation Test', () => {
 
   it('should correctly heapify an array', () => {
     const array = [5, 3, 7, 1];
-    const heap = MaxPriorityQueue.heapify<number>(array, (a, b) => b - a);
+    const heap = MaxPriorityQueue.heapify<number>({nodes: array, comparator: (a, b) => b - a});
     heap.refill(array);
 
     expect(heap.poll()).toBe(7);
@@ -64,7 +64,7 @@ describe('MaxPriorityQueue Operation Test', () => {
 
   it('should correctly heapify an object array', () => {
     const nodes = [{keyA: 5}, {keyA: 3}, {keyA: 7}, {keyA: 1}];
-    const maxPQ = MaxPriorityQueue.heapify<{keyA: number}>(nodes, (a, b) => b.keyA - a.keyA);
+    const maxPQ = MaxPriorityQueue.heapify<{ keyA: number }>({nodes: nodes, comparator: (a, b) => b.keyA - a.keyA});
 
     expect(maxPQ.poll()?.keyA).toBe(7);
     expect(maxPQ.poll()?.keyA).toBe(5);