min-heap-typed 1.41.7 → 1.41.9

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

@@ -26,6 +26,8 @@ export declare class RedBlackTree {
     constructor();
     protected _root: RBTreeNode;
     get root(): RBTreeNode;
+    protected _size: number;
+    get size(): number;
     /**
      * The `insert` function inserts a new node with a given key into a red-black tree and fixes any
      * violations of the red-black tree properties.
@@ -33,11 +35,11 @@ export declare class RedBlackTree {
      * the RBTree.
      * @returns The function does not explicitly return anything.
      */
-    insert(key: number): void;
+    add(key: number): void;
     /**
      * The `delete` function in TypeScript is used to remove a node with a specific key from a red-black
      * tree.
-     * @param {RBTreeNode} node - The `node` parameter is of type `RBTreeNode` and represents the current
+     * @param {number} key - The `node` parameter is of type `RBTreeNode` and represents the current
      * node being processed in the delete operation.
      * @returns The `delete` function does not return anything. It has a return type of `void`.
      */
@@ -80,6 +82,7 @@ export declare class RedBlackTree {
      * @returns the predecessor of the given RBTreeNode 'x'.
      */
     getPredecessor(x: RBTreeNode): RBTreeNode;
+    clear(): void;
     print(beginRoot?: RBTreeNode): void;
     /**
      * The function performs a left rotation on a red-black tree node.

package/dist/data-structures/binary-tree/rb-tree.js

@@ -30,11 +30,15 @@ exports.NIL = new RBTreeNode(0);
  */
 class RedBlackTree {
     constructor() {
+        this._size = 0;
         this._root = exports.NIL;
     }
     get root() {
         return this._root;
     }
+    get size() {
+        return this._size;
+    }
     /**
      * The `insert` function inserts a new node with a given key into a red-black tree and fixes any
      * violations of the red-black tree properties.
@@ -42,7 +46,7 @@ class RedBlackTree {
      * the RBTree.
      * @returns The function does not explicitly return anything.
      */
-    insert(key) {
+    add(key) {
         const node = new RBTreeNode(key, types_1.RBTNColor.RED);
         node.left = exports.NIL;
         node.right = exports.NIL;
@@ -69,17 +73,20 @@ class RedBlackTree {
         }
         if (node.parent === null) {
             node.color = types_1.RBTNColor.BLACK;
+            this._size++;
             return;
         }
         if (node.parent.parent === null) {
+            this._size++;
             return;
         }
         this._fixInsert(node);
+        this._size++;
     }
     /**
      * The `delete` function in TypeScript is used to remove a node with a specific key from a red-black
      * tree.
-     * @param {RBTreeNode} node - The `node` parameter is of type `RBTreeNode` and represents the current
+     * @param {number} key - The `node` parameter is of type `RBTreeNode` and represents the current
      * node being processed in the delete operation.
      * @returns The `delete` function does not return anything. It has a return type of `void`.
      */
@@ -99,6 +106,7 @@ class RedBlackTree {
                 }
             }
             if (z === exports.NIL) {
+                this._size--;
                 return;
             }
             y = z;
@@ -131,6 +139,7 @@ class RedBlackTree {
             if (yOriginalColor === types_1.RBTNColor.BLACK) {
                 this._fixDelete(x);
             }
+            this._size--;
         };
         helper(this.root);
     }
@@ -219,6 +228,10 @@ class RedBlackTree {
         }
         return y;
     }
+    clear() {
+        this._root = exports.NIL;
+        this._size = 0;
+    }
     print(beginRoot = this.root) {
         const display = (root) => {
             const [lines, , ,] = _displayAux(root);

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

@@ -114,9 +114,10 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * @param {VO | VertexKey} v1 - The parameter `v1` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
      * It is the starting vertex for finding paths.
      * @param {VO | VertexKey} v2 - The parameter `v2` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
+     * @param limit - The count of limitation of result array.
      * @returns The function `getAllPathsBetween` returns an array of arrays of vertices (`VO[][]`).
      */
-    getAllPathsBetween(v1: VO | VertexKey, v2: VO | VertexKey): VO[][];
+    getAllPathsBetween(v1: VO | VertexKey, v2: VO | VertexKey, limit?: number): VO[][];
     /**
      * The function calculates the sum of weights along a given path.
      * @param {VO[]} path - An array of vertices (VO) representing a path in a graph.
@@ -148,10 +149,13 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * @param {boolean} [isWeight] - A boolean flag indicating whether to consider the weight of edges in finding the
      * minimum path. If set to true, the function will use Dijkstra's algorithm to find the minimum weighted path. If set
      * to false, the function will use breadth-first search (BFS) to find the minimum path.
+     * @param isDFS - If set to true, it enforces the use of getAllPathsBetween to first obtain all possible paths,
+     * followed by iterative computation of the shortest path. This approach may result in exponential time complexity,
+     * so the default method is to use the Dijkstra algorithm to obtain the shortest weighted path.
      * @returns The function `getMinPathBetween` returns an array of vertices (`VO[]`) representing the minimum path between
      * two vertices (`v1` and `v2`). If there is no path between the vertices, it returns `null`.
      */
-    getMinPathBetween(v1: VO | VertexKey, v2: VO | VertexKey, isWeight?: boolean): VO[] | null;
+    getMinPathBetween(v1: VO | VertexKey, v2: VO | VertexKey, isWeight?: boolean, isDFS?: boolean): VO[] | null;
     /**
      * Dijkstra algorithm time: O(VE) space: O(VO + EO)
      * /

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

@@ -4,8 +4,8 @@ exports.AbstractGraph = exports.AbstractEdge = exports.AbstractVertex = void 0;
 /**
  * data-structure-typed
  *
- * @author Kirk Qi
- * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
 const utils_1 = require("../../utils");
@@ -162,31 +162,33 @@ class AbstractGraph {
      * @param {VO | VertexKey} v1 - The parameter `v1` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
      * It is the starting vertex for finding paths.
      * @param {VO | VertexKey} v2 - The parameter `v2` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
+     * @param limit - The count of limitation of result array.
      * @returns The function `getAllPathsBetween` returns an array of arrays of vertices (`VO[][]`).
      */
-    getAllPathsBetween(v1, v2) {
+    getAllPathsBetween(v1, v2, limit = 1000) {
         const paths = [];
         const vertex1 = this._getVertex(v1);
         const vertex2 = this._getVertex(v2);
         if (!(vertex1 && vertex2)) {
             return [];
         }
-        const dfs = (cur, dest, visiting, path) => {
-            visiting.add(cur);
-            if (cur === dest) {
-                paths.push([vertex1, ...path]);
+        const stack = [];
+        stack.push({ vertex: vertex1, path: [vertex1] });
+        while (stack.length > 0) {
+            const { vertex, path } = stack.pop();
+            if (vertex === vertex2) {
+                paths.push(path);
+                if (paths.length >= limit)
+                    return paths;
             }
-            const neighbors = this.getNeighbors(cur);
+            const neighbors = this.getNeighbors(vertex);
             for (const neighbor of neighbors) {
-                if (!visiting.has(neighbor)) {
-                    path.push(neighbor);
-                    dfs(neighbor, dest, visiting, path);
-                    path.pop();
+                if (!path.includes(neighbor)) {
+                    const newPath = [...path, neighbor];
+                    stack.push({ vertex: neighbor, path: newPath });
                 }
             }
-            visiting.delete(cur);
-        };
-        dfs(vertex1, vertex2, new Set(), []);
+        }
         return paths;
     }
     /**
@@ -270,52 +272,60 @@ class AbstractGraph {
      * @param {boolean} [isWeight] - A boolean flag indicating whether to consider the weight of edges in finding the
      * minimum path. If set to true, the function will use Dijkstra's algorithm to find the minimum weighted path. If set
      * to false, the function will use breadth-first search (BFS) to find the minimum path.
+     * @param isDFS - If set to true, it enforces the use of getAllPathsBetween to first obtain all possible paths,
+     * followed by iterative computation of the shortest path. This approach may result in exponential time complexity,
+     * so the default method is to use the Dijkstra algorithm to obtain the shortest weighted path.
      * @returns The function `getMinPathBetween` returns an array of vertices (`VO[]`) representing the minimum path between
      * two vertices (`v1` and `v2`). If there is no path between the vertices, it returns `null`.
      */
-    getMinPathBetween(v1, v2, isWeight) {
+    getMinPathBetween(v1, v2, isWeight, isDFS = false) {
+        var _a, _b;
         if (isWeight === undefined)
             isWeight = false;
         if (isWeight) {
-            const allPaths = this.getAllPathsBetween(v1, v2);
-            let min = Infinity;
-            let minIndex = -1;
-            let index = 0;
-            for (const path of allPaths) {
-                const pathSumWeight = this.getPathSumWeight(path);
-                if (pathSumWeight < min) {
-                    min = pathSumWeight;
-                    minIndex = index;
+            if (isDFS) {
+                const allPaths = this.getAllPathsBetween(v1, v2, 10000);
+                let min = Infinity;
+                let minIndex = -1;
+                let index = 0;
+                for (const path of allPaths) {
+                    const pathSumWeight = this.getPathSumWeight(path);
+                    if (pathSumWeight < min) {
+                        min = pathSumWeight;
+                        minIndex = index;
+                    }
+                    index++;
                 }
-                index++;
+                return allPaths[minIndex] || null;
+            }
+            else {
+                return (_b = (_a = this.dijkstra(v1, v2, true, true)) === null || _a === void 0 ? void 0 : _a.minPath) !== null && _b !== void 0 ? _b : [];
             }
-            return allPaths[minIndex] || null;
         }
         else {
-            // BFS
+            // DFS
             let minPath = [];
             const vertex1 = this._getVertex(v1);
             const vertex2 = this._getVertex(v2);
-            if (!(vertex1 && vertex2)) {
+            if (!(vertex1 && vertex2))
                 return [];
-            }
             const dfs = (cur, dest, visiting, path) => {
-                visiting.set(cur, true);
+                visiting.add(cur);
                 if (cur === dest) {
                     minPath = [vertex1, ...path];
                     return;
                 }
                 const neighbors = this.getNeighbors(cur);
                 for (const neighbor of neighbors) {
-                    if (!visiting.get(neighbor)) {
+                    if (!visiting.has(neighbor)) {
                         path.push(neighbor);
                         dfs(neighbor, dest, visiting, path);
-                        (0, utils_1.arrayRemove)(path, (vertex) => vertex === neighbor);
+                        path.pop();
                     }
                 }
-                visiting.set(cur, false);
+                visiting.delete(cur);
             };
-            dfs(vertex1, vertex2, new Map(), []);
+            dfs(vertex1, vertex2, new Set(), []);
             return minPath;
         }
     }

package/package.json

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

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

@@ -142,7 +142,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
   }
 
   protected defaultOneParamCallback = (node: N) => node.key;
-  
+
   /**
    * Creates a new instance of BinaryTreeNode with the given key and value.
    * @param {BTNKey} key - The key for the new node.

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

@@ -36,7 +36,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
       }
     }
   }
-  
+
   /**
    * The function creates a new binary search tree node with the given key and value.
    * @param {BTNKey} key - The key parameter is the key value that will be associated with

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

@@ -44,6 +44,12 @@ export class RedBlackTree {
     return this._root;
   }
 
+  protected _size: number = 0;
+
+  get size(): number {
+    return this._size;
+  }
+
   /**
    * The `insert` function inserts a new node with a given key into a red-black tree and fixes any
    * violations of the red-black tree properties.
@@ -51,7 +57,7 @@ export class RedBlackTree {
    * the RBTree.
    * @returns The function does not explicitly return anything.
    */
-  insert(key: number): void {
+  add(key: number): void {
     const node: RBTreeNode = new RBTreeNode(key, RBTNColor.RED);
     node.left = NIL;
     node.right = NIL;
@@ -79,20 +85,23 @@ export class RedBlackTree {
 
     if (node.parent === null) {
       node.color = RBTNColor.BLACK;
+      this._size++;
       return;
     }
 
     if (node.parent.parent === null) {
+      this._size++;
       return;
     }
 
     this._fixInsert(node);
+    this._size++;
   }
 
   /**
    * The `delete` function in TypeScript is used to remove a node with a specific key from a red-black
    * tree.
-   * @param {RBTreeNode} node - The `node` parameter is of type `RBTreeNode` and represents the current
+   * @param {number} key - The `node` parameter is of type `RBTreeNode` and represents the current
    * node being processed in the delete operation.
    * @returns The `delete` function does not return anything. It has a return type of `void`.
    */
@@ -113,6 +122,7 @@ export class RedBlackTree {
       }
 
       if (z === NIL) {
+        this._size--;
         return;
       }
 
@@ -144,6 +154,7 @@ export class RedBlackTree {
       if (yOriginalColor === RBTNColor.BLACK) {
         this._fixDelete(x);
       }
+      this._size--;
     };
     helper(this.root);
   }
@@ -241,6 +252,11 @@ export class RedBlackTree {
     return y;
   }
 
+  clear() {
+    this._root = NIL;
+    this._size = 0;
+  }
+
   print(beginRoot: RBTreeNode = this.root) {
     const display = (root: RBTreeNode | null): void => {
       const [lines, , ,] = _displayAux(root);

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

@@ -1,11 +1,11 @@
 /**
  * data-structure-typed
  *
- * @author Kirk Qi
- * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import {arrayRemove, uuidV4} from '../../utils';
+import {uuidV4} from '../../utils';
 import {PriorityQueue} from '../priority-queue';
 import type {DijkstraResult, VertexKey} from '../../types';
 import {IGraph} from '../../interfaces';
@@ -223,39 +223,43 @@ export abstract class AbstractGraph<
    * @param {VO | VertexKey} v1 - The parameter `v1` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
    * It is the starting vertex for finding paths.
    * @param {VO | VertexKey} v2 - The parameter `v2` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
+   * @param limit - The count of limitation of result array.
    * @returns The function `getAllPathsBetween` returns an array of arrays of vertices (`VO[][]`).
    */
-  getAllPathsBetween(v1: VO | VertexKey, v2: VO | VertexKey): VO[][] {
+  getAllPathsBetween(v1: VO | VertexKey, v2: VO | VertexKey, limit = 1000): VO[][] {
     const paths: VO[][] = [];
     const vertex1 = this._getVertex(v1);
     const vertex2 = this._getVertex(v2);
+
     if (!(vertex1 && vertex2)) {
       return [];
     }
 
-    const dfs = (cur: VO, dest: VO, visiting: Set<VO>, path: VO[]) => {
-      visiting.add(cur);
+    const stack: { vertex: VO, path: VO[] }[] = [];
+    stack.push({ vertex: vertex1, path: [vertex1] });
+
+    while (stack.length > 0) {
+      const { vertex, path } = stack.pop()!;
 
-      if (cur === dest) {
-        paths.push([vertex1, ...path]);
+      if (vertex === vertex2) {
+        paths.push(path);
+        if (paths.length >= limit) return paths;
       }
 
-      const neighbors = this.getNeighbors(cur);
+      const neighbors = this.getNeighbors(vertex);
       for (const neighbor of neighbors) {
-        if (!visiting.has(neighbor)) {
-          path.push(neighbor);
-          dfs(neighbor, dest, visiting, path);
-          path.pop();
+        if (!path.includes(neighbor)) {
+          const newPath = [...path, neighbor];
+          stack.push({ vertex: neighbor, path: newPath });
         }
       }
-
-      visiting.delete(cur);
-    };
-
-    dfs(vertex1, vertex2, new Set<VO>(), []);
+    }
     return paths;
   }
 
+
+
+
   /**
    * The function calculates the sum of weights along a given path.
    * @param {VO[]} path - An array of vertices (VO) representing a path in a graph.
@@ -338,38 +342,43 @@ export abstract class AbstractGraph<
    * @param {boolean} [isWeight] - A boolean flag indicating whether to consider the weight of edges in finding the
    * minimum path. If set to true, the function will use Dijkstra's algorithm to find the minimum weighted path. If set
    * to false, the function will use breadth-first search (BFS) to find the minimum path.
+   * @param isDFS - If set to true, it enforces the use of getAllPathsBetween to first obtain all possible paths,
+   * followed by iterative computation of the shortest path. This approach may result in exponential time complexity,
+   * so the default method is to use the Dijkstra algorithm to obtain the shortest weighted path.
    * @returns The function `getMinPathBetween` returns an array of vertices (`VO[]`) representing the minimum path between
    * two vertices (`v1` and `v2`). If there is no path between the vertices, it returns `null`.
    */
-  getMinPathBetween(v1: VO | VertexKey, v2: VO | VertexKey, isWeight?: boolean): VO[] | null {
+  getMinPathBetween(v1: VO | VertexKey, v2: VO | VertexKey, isWeight?: boolean, isDFS = false): VO[] | null {
     if (isWeight === undefined) isWeight = false;
 
     if (isWeight) {
-      const allPaths = this.getAllPathsBetween(v1, v2);
-      let min = Infinity;
-      let minIndex = -1;
-      let index = 0;
-      for (const path of allPaths) {
-        const pathSumWeight = this.getPathSumWeight(path);
-        if (pathSumWeight < min) {
-          min = pathSumWeight;
-          minIndex = index;
+      if (isDFS) {
+        const allPaths = this.getAllPathsBetween(v1, v2, 10000);
+        let min = Infinity;
+        let minIndex = -1;
+        let index = 0;
+        for (const path of allPaths) {
+          const pathSumWeight = this.getPathSumWeight(path);
+          if (pathSumWeight < min) {
+            min = pathSumWeight;
+            minIndex = index;
+          }
+          index++;
         }
-        index++;
+        return allPaths[minIndex] || null;
+      } else {
+        return this.dijkstra(v1, v2, true, true)?.minPath ?? [];
       }
-      return allPaths[minIndex] || null;
+
     } else {
-      // BFS
+      // DFS
       let minPath: VO[] = [];
       const vertex1 = this._getVertex(v1);
       const vertex2 = this._getVertex(v2);
-      if (!(vertex1 && vertex2)) {
-        return [];
-      }
-
-      const dfs = (cur: VO, dest: VO, visiting: Map<VO, boolean>, path: VO[]) => {
-        visiting.set(cur, true);
+      if (!(vertex1 && vertex2)) return [];
 
+      const dfs = (cur: VO, dest: VO, visiting: Set<VO>, path: VO[]) => {
+        visiting.add(cur);
         if (cur === dest) {
           minPath = [vertex1, ...path];
           return;
@@ -377,17 +386,17 @@ export abstract class AbstractGraph<
 
         const neighbors = this.getNeighbors(cur);
         for (const neighbor of neighbors) {
-          if (!visiting.get(neighbor)) {
+          if (!visiting.has(neighbor)) {
             path.push(neighbor);
             dfs(neighbor, dest, visiting, path);
-            arrayRemove(path, (vertex: VO) => vertex === neighbor);
+            path.pop();
           }
         }
 
-        visiting.set(cur, false);
+        visiting.delete(cur);
       };
 
-      dfs(vertex1, vertex2, new Map<VO, boolean>(), []);
+      dfs(vertex1, vertex2, new Set<VO>(), []);
       return minPath;
     }
   }