min-heap-typed 1.38.9 → 1.39.0

package/dist/data-structures/binary-tree/binary-indexed-tree.d.ts

@@ -69,6 +69,14 @@ export declare class BinaryIndexedTree {
      * @returns The upperBound function is returning a number.
      */
     upperBound(sum: number): number;
+    /**
+     * 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;
     /**
      * 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/dist/data-structures/binary-tree/binary-indexed-tree.js

@@ -120,6 +120,23 @@ 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) {
+        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/dist/data-structures/graph/abstract-graph.d.ts

@@ -65,7 +65,7 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any> = Abst
      * @param val
      */
     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;
     abstract degreeOf(vertexOrKey: V | VertexKey): number;
     abstract edgeSet(): E[];
@@ -90,12 +90,12 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any> = Abst
     addVertex(vertex: V): boolean;
     addVertex(key: VertexKey, val?: V['val']): boolean;
     /**
-     * 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;
     /**
      * The function removes all vertices from a graph and returns a boolean indicating if any vertices were removed.
      * @param {V[] | VertexKey[]} vertices - The `vertices` parameter can be either an array of vertices (`V[]`) or an array

package/dist/data-structures/graph/abstract-graph.js

@@ -117,12 +117,12 @@ 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) {
+    deleteVertex(vertexOrKey) {
         const vertexKey = this._getVertexKey(vertexOrKey);
         return this._vertices.delete(vertexKey);
     }
@@ -136,7 +136,7 @@ class AbstractGraph {
     removeAllVertices(vertices) {
         const removed = [];
         for (const v of vertices) {
-            removed.push(this.removeVertex(v));
+            removed.push(this.deleteVertex(v));
         }
         return removed.length > 0;
     }
@@ -529,7 +529,7 @@ class AbstractGraph {
             if (vertexOrKey instanceof AbstractVertex)
                 distMap.set(vertexOrKey, Infinity);
         }
-        const heap = new priority_queue_1.PriorityQueue((a, b) => a.key - b.key);
+        const heap = new priority_queue_1.PriorityQueue({ comparator: (a, b) => a.key - b.key });
         heap.add({ key: 0, val: srcVertex });
         distMap.set(srcVertex, 0);
         preMap.set(srcVertex, null);

package/dist/data-structures/graph/directed-graph.d.ts

@@ -84,14 +84,14 @@ export declare class DirectedGraph<V extends DirectedVertex<any> = DirectedVerte
      * @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;
     /**
      * 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;
     /**
      * The function removes edges between two vertices and returns the removed edges.
      * @param {VertexKey | V} v1 - The parameter `v1` can be either a `VertexKey` or a `V`. A `VertexKey` represents the
@@ -100,7 +100,7 @@ export declare class DirectedGraph<V extends DirectedVertex<any> = DirectedVerte
      * 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[];
     /**
      * The function `incomingEdgesOf` returns an array of incoming edges for a given vertex or vertex ID.
      * @param {V | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`V`) or a vertex ID

package/dist/data-structures/graph/directed-graph.js

@@ -130,7 +130,7 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
      * @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, destOrKey) {
+    deleteEdgeSrcToDest(srcOrKey, destOrKey) {
         const src = this._getVertex(srcOrKey);
         const dest = this._getVertex(destOrKey);
         let removed = null;
@@ -151,9 +151,9 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
      * 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) {
+    deleteEdge(edge) {
         let removed = null;
         const src = this._getVertex(edge.src);
         const dest = this._getVertex(edge.dest);
@@ -177,11 +177,11 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
      * the second vertex in the edge that needs to be removed.
      * @returns an array of removed edges (E[]).
      */
-    removeEdgesBetween(v1, v2) {
+    deleteEdgesBetween(v1, v2) {
         const removed = [];
         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/dist/data-structures/graph/undirected-graph.d.ts

@@ -71,13 +71,13 @@ export declare class UndirectedGraph<V extends UndirectedVertex<any> = Undirecte
      * (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;
     /**
-     * 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;
+    deleteEdge(edge: E): E | null;
     /**
      * The function `degreeOf` returns the degree of a vertex in a graph, which is the number of edges connected to that
      * vertex.

package/dist/data-structures/graph/undirected-graph.js

@@ -109,7 +109,7 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
      * (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, v2) {
+    deleteEdgeBetween(v1, v2) {
         const vertex1 = this._getVertex(v1);
         const vertex2 = this._getVertex(v2);
         if (!vertex1 || !vertex2) {
@@ -127,12 +127,12 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
         return removed;
     }
     /**
-     * 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) {
-        return this.removeEdgeBetween(edge.vertices[0], edge.vertices[1]);
+    deleteEdge(edge) {
+        return this.deleteEdgeBetween(edge.vertices[0], edge.vertices[1]);
     }
     /**
      * The function `degreeOf` returns the degree of a vertex in a graph, which is the number of edges connected to that

package/dist/data-structures/heap/heap.d.ts

@@ -5,10 +5,13 @@
  * @license MIT License
  */
 import type { Comparator, DFSOrderPattern } from '../../types';
-export declare class Heap<E> {
+export declare class Heap<E = any> {
     protected nodes: E[];
     protected readonly comparator: Comparator<E>;
-    constructor(comparator: Comparator<E>);
+    constructor(options: {
+        comparator: Comparator<E>;
+        nodes?: E[];
+    });
     /**
      * Get the size (number of elements) of the heap.
      */
@@ -20,11 +23,13 @@ export declare class Heap<E> {
     get leaf(): E | undefined;
     /**
      * 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>;
+    static heapify<E>(options: {
+        nodes: E[];
+        comparator: Comparator<E>;
+    }): Heap<E>;
     /**
      * Insert an element into the heap and maintain the heap properties.
      * @param element - The element to be inserted.

package/dist/data-structures/heap/heap.js

@@ -8,9 +8,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FibonacciHeap = exports.FibonacciHeapNode = exports.Heap = void 0;
 class Heap {
-    constructor(comparator) {
+    constructor(options) {
         this.nodes = [];
-        this.comparator = comparator;
+        this.comparator = options.comparator;
+        if (options.nodes && options.nodes.length > 0) {
+            this.nodes = options.nodes;
+            this.fix();
+        }
     }
     /**
      * Get the size (number of elements) of the heap.
@@ -28,15 +32,11 @@ class Heap {
     }
     /**
      * 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(nodes, comparator) {
-        const binaryHeap = new Heap(comparator);
-        binaryHeap.nodes = [...nodes];
-        binaryHeap.fix(); // Fix heap properties
-        return binaryHeap;
+    static heapify(options) {
+        return new Heap(options);
     }
     /**
      * Insert an element into the heap and maintain the heap properties.
@@ -161,7 +161,7 @@ class Heap {
      * @returns A new Heap instance containing the same elements.
      */
     clone() {
-        const clonedHeap = new Heap(this.comparator);
+        const clonedHeap = new Heap({ comparator: this.comparator });
         clonedHeap.nodes = [...this.nodes];
         return clonedHeap;
     }

package/dist/data-structures/heap/max-heap.d.ts

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

package/dist/data-structures/heap/max-heap.js

@@ -10,15 +10,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MaxHeap = void 0;
 const heap_1 = require("./heap");
 class MaxHeap extends heap_1.Heap {
-    constructor(comparator = (a, b) => {
-        if (!(typeof a === 'number' && typeof b === 'number')) {
-            throw new Error('The a, b params of compare function must be number');
-        }
-        else {
-            return b - a;
+    constructor(options = {
+        comparator: (a, b) => {
+            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);
     }
 }
 exports.MaxHeap = MaxHeap;

package/dist/data-structures/heap/min-heap.d.ts

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

package/dist/data-structures/heap/min-heap.js

@@ -10,15 +10,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MinHeap = void 0;
 const heap_1 = require("./heap");
 class MinHeap extends heap_1.Heap {
-    constructor(comparator = (a, b) => {
-        if (!(typeof a === 'number' && typeof b === 'number')) {
-            throw new Error('The a, b params of compare function must be number');
-        }
-        else {
-            return a - b;
+    constructor(options = {
+        comparator: (a, b) => {
+            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);
     }
 }
 exports.MinHeap = MinHeap;

package/dist/data-structures/priority-queue/max-priority-queue.d.ts

@@ -8,5 +8,8 @@
 import { PriorityQueue } from './priority-queue';
 import type { Comparator } from '../../types';
 export declare class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
-    constructor(compare?: Comparator<E>);
+    constructor(options?: {
+        comparator: Comparator<E>;
+        nodes?: E[];
+    });
 }

package/dist/data-structures/priority-queue/max-priority-queue.js

@@ -10,15 +10,17 @@ exports.MaxPriorityQueue = void 0;
  */
 const priority_queue_1 = require("./priority-queue");
 class MaxPriorityQueue extends priority_queue_1.PriorityQueue {
-    constructor(compare = (a, b) => {
-        if (!(typeof a === 'number' && typeof b === 'number')) {
-            throw new Error('The a, b params of compare function must be number');
-        }
-        else {
-            return b - a;
+    constructor(options = {
+        comparator: (a, b) => {
+            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);
     }
 }
 exports.MaxPriorityQueue = MaxPriorityQueue;

package/dist/data-structures/priority-queue/min-priority-queue.d.ts

@@ -8,5 +8,8 @@
 import { PriorityQueue } from './priority-queue';
 import type { Comparator } from '../../types';
 export declare class MinPriorityQueue<E = any> extends PriorityQueue<E> {
-    constructor(compare?: Comparator<E>);
+    constructor(options?: {
+        comparator: Comparator<E>;
+        nodes?: E[];
+    });
 }

package/dist/data-structures/priority-queue/min-priority-queue.js

@@ -10,15 +10,17 @@ exports.MinPriorityQueue = void 0;
  */
 const priority_queue_1 = require("./priority-queue");
 class MinPriorityQueue extends priority_queue_1.PriorityQueue {
-    constructor(compare = (a, b) => {
-        if (!(typeof a === 'number' && typeof b === 'number')) {
-            throw new Error('The a, b params of compare function must be number');
-        }
-        else {
-            return a - b;
+    constructor(options = {
+        comparator: (a, b) => {
+            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);
     }
 }
 exports.MinPriorityQueue = MinPriorityQueue;

package/dist/data-structures/priority-queue/priority-queue.d.ts

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

package/dist/data-structures/priority-queue/priority-queue.js

@@ -10,8 +10,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PriorityQueue = void 0;
 const heap_1 = require("../heap");
 class PriorityQueue extends heap_1.Heap {
-    constructor(comparator) {
-        super(comparator);
+    constructor(options) {
+        super(options);
     }
 }
 exports.PriorityQueue = PriorityQueue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "min-heap-typed",
-  "version": "1.38.9",
+  "version": "1.39.0",
   "description": "Min Heap. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -131,6 +131,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.38.9"
+    "data-structure-typed": "^1.39.0"
   }
 }

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);
   }
 }