data-structure-typed 1.38.8 → 1.39.0

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

@@ -110,7 +110,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) {
@@ -128,12 +128,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/mjs/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/mjs/data-structures/heap/heap.js

@@ -10,8 +10,12 @@ exports.FibonacciHeap = exports.FibonacciHeapNode = exports.Heap = void 0;
 class Heap {
     nodes = [];
     comparator;
-    constructor(comparator) {
-        this.comparator = comparator;
+    constructor(options) {
+        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/mjs/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/mjs/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/mjs/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/mjs/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/mjs/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/mjs/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/mjs/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/mjs/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/mjs/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/mjs/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/dist/mjs/data-structures/trie/trie.d.ts

@@ -77,8 +77,9 @@ export declare class Trie {
      * @param {string} prefix - The `prefix` parameter is a string that represents the prefix that we want to search for in the
      * trie. It is an optional parameter, so if no prefix is provided, it will default to an empty string.
      * @param {number} max - The max count of words will be found
+     * @param isAllWhenEmptyPrefix - If true, when the prefix provided as '', returns all the words in the trie.
      * @returns {string[]} an array of strings.
      */
-    getWords(prefix?: string, max?: number): string[];
+    getWords(prefix?: string, max?: number, isAllWhenEmptyPrefix?: boolean): string[];
     private _caseProcess;
 }

package/dist/mjs/data-structures/trie/trie.js

@@ -231,9 +231,10 @@ class Trie {
      * @param {string} prefix - The `prefix` parameter is a string that represents the prefix that we want to search for in the
      * trie. It is an optional parameter, so if no prefix is provided, it will default to an empty string.
      * @param {number} max - The max count of words will be found
+     * @param isAllWhenEmptyPrefix - If true, when the prefix provided as '', returns all the words in the trie.
      * @returns {string[]} an array of strings.
      */
-    getWords(prefix = '', max = Number.MAX_SAFE_INTEGER) {
+    getWords(prefix = '', max = Number.MAX_SAFE_INTEGER, isAllWhenEmptyPrefix = false) {
         prefix = this._caseProcess(prefix);
         const words = [];
         let found = 0;
@@ -259,7 +260,7 @@ class Trie {
                     startNode = nodeC;
             }
         }
-        if (startNode !== this.root)
+        if (isAllWhenEmptyPrefix || startNode !== this.root)
             dfs(startNode, prefix);
         return words;
     }