data-structure-typed 1.52.4 → 1.52.5

package/dist/mjs/data-structures/binary-tree/tree-multi-map.js

@@ -57,10 +57,6 @@ export class TreeMultiMap extends RedBlackTree {
     get count() {
         return this._count;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -121,17 +117,17 @@ export class TreeMultiMap extends RedBlackTree {
             return;
         if (this.isNode(keyOrNodeOrEntryOrRawElement))
             return keyOrNodeOrEntryOrRawElement;
-        if (this.toEntryFn) {
-            const [key] = this.toEntryFn(keyOrNodeOrEntryOrRawElement);
-            if (key)
-                return this.getNodeByKey(key);
-        }
         if (this.isEntry(keyOrNodeOrEntryOrRawElement)) {
-            const [key, value] = keyOrNodeOrEntryOrRawElement;
+            const [key, entryValue] = keyOrNodeOrEntryOrRawElement;
             if (key === undefined || key === null)
                 return;
-            else
-                return this.createNode(key, value, 'BLACK', count);
+            if (this.isKey(key))
+                return this.createNode(key, value ?? entryValue, 'BLACK', count);
+        }
+        if (this.toEntryFn) {
+            const [key, entryValue] = this.toEntryFn(keyOrNodeOrEntryOrRawElement);
+            if (this.isKey(key))
+                return this.createNode(key, value ?? entryValue, 'BLACK', count);
         }
         if (this.isKey(keyOrNodeOrEntryOrRawElement))
             return this.createNode(keyOrNodeOrEntryOrRawElement, value, 'BLACK', count);
@@ -147,10 +143,6 @@ export class TreeMultiMap extends RedBlackTree {
     isNode(keyOrNodeOrEntryOrRawElement) {
         return keyOrNodeOrEntryOrRawElement instanceof TreeMultiMapNode;
     }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -179,10 +171,6 @@ export class TreeMultiMap extends RedBlackTree {
             return false;
         }
     }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -239,7 +227,7 @@ export class TreeMultiMap extends RedBlackTree {
             }
         }
         else {
-            const successor = this.getLeftMost(nodeToDelete.right);
+            const successor = this.getLeftMost(node => node, nodeToDelete.right);
             if (successor) {
                 originalColor = successor.color;
                 replacementNode = successor.right;
@@ -289,10 +277,6 @@ export class TreeMultiMap extends RedBlackTree {
         results.push({ deleted: nodeToDelete, needBalanced: undefined });
         return results;
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -304,10 +288,6 @@ export class TreeMultiMap extends RedBlackTree {
         super.clear();
         this._count = 0;
     }
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(log n)
-     */
     /**
      * Time Complexity: O(n log n)
      * Space Complexity: O(log n)
@@ -357,10 +337,6 @@ export class TreeMultiMap extends RedBlackTree {
             return true;
         }
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -373,10 +349,6 @@ export class TreeMultiMap extends RedBlackTree {
         this.bfs(node => cloned.add(node.key, node.value, node.count));
         return cloned;
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -412,10 +384,6 @@ export class TreeMultiMap extends RedBlackTree {
         }
         return undefined;
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -65,10 +65,6 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
     abstract edgesOf(vertexOrKey: VO | VertexKey): EO[];
     abstract getNeighbors(vertexOrKey: VO | VertexKey): VO[];
     abstract getEndsOfEdge(edge: EO): [VO, VO] | undefined;
-    /**
-     * Time Complexity: O(1) - Constant time for Map lookup.
-     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
-     */
     /**
      * Time Complexity: O(1) - Constant time for Map lookup.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
@@ -80,10 +76,6 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * map. If the vertex does not exist, it returns `undefined`.
      */
     getVertex(vertexKey: VertexKey): VO | undefined;
-    /**
-     * Time Complexity: O(1) - Constant time for Map lookup.
-     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
-     */
     /**
      * Time Complexity: O(1) - Constant time for Map lookup.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
@@ -102,10 +94,6 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
      */
     abstract deleteVertex(vertexOrKey: VO | VertexKey): boolean;
-    /**
-     * Time Complexity: O(K), where K is the number of vertexMap to be removed.
-     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
-     */
     /**
      * Time Complexity: O(K), where K is the number of vertexMap to be removed.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
@@ -117,10 +105,6 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * were removed.
      */
     removeManyVertices(vertexMap: VO[] | VertexKey[]): boolean;
-    /**
-     * Time Complexity: O(1) - Depends on the implementation in the concrete class.
-     * Space Complexity: O(1) - Depends on the implementation in the concrete class.
-     */
     /**
      * Time Complexity: O(1) - Depends on the implementation in the concrete class.
      * Space Complexity: O(1) - Depends on the implementation in the concrete class.
@@ -135,10 +119,6 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
     hasEdge(v1: VertexKey | VO, v2: VertexKey | VO): boolean;
     addEdge(edge: EO): boolean;
     addEdge(src: VO | VertexKey, dest: VO | VertexKey, weight?: number, value?: E): boolean;
-    /**
-     * Time Complexity: O(1) - Constant time for Map and Edge operations.
-     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
-     */
     /**
      * Time Complexity: O(1) - Constant time for Map and Edge operations.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
@@ -154,10 +134,6 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * the weight of the edge and return true. If the edge does not exist, the function will return false.
      */
     setEdgeWeight(srcOrKey: VertexKey | VO, destOrKey: VertexKey | VO, weight: number): boolean;
-    /**
-     * Time Complexity: O(P), where P is the number of paths found (in the worst case, exploring all paths).
-     * Space Complexity: O(P) - Linear space, where P is the number of paths found.
-     */
     /**
      * Time Complexity: O(P), where P is the number of paths found (in the worst case, exploring all paths).
      * Space Complexity: O(P) - Linear space, where P is the number of paths found.
@@ -170,10 +146,6 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * @returns The function `getAllPathsBetween` returns an array of arrays of vertexMap (`VO[][]`).
      */
     getAllPathsBetween(v1: VO | VertexKey, v2: VO | VertexKey, limit?: number): VO[][];
-    /**
-     * Time Complexity: O(L), where L is the length of the path.
-     * Space Complexity: O(1) - Constant space.
-     */
     /**
      * Time Complexity: O(L), where L is the length of the path.
      * Space Complexity: O(1) - Constant space.
@@ -183,10 +155,6 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * @returns The function `getPathSumWeight` returns the sum of the weights of the edgeMap in the given path.
      */
     getPathSumWeight(path: VO[]): number;
-    /**
-     * Time Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
-     * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
-     */
     /**
      * Time Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
      * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
@@ -205,10 +173,6 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * minimum number of
      */
     getMinCostBetween(v1: VO | VertexKey, v2: VO | VertexKey, isWeight?: boolean): number | undefined;
-    /**
-     * Time Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm or DFS).
-     * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm or DFS).
-     */
     /**
      * Time Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm or DFS).
      * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm or DFS).
@@ -229,13 +193,6 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * two vertexMap (`v1` and `v2`). If there is no path between the vertexMap, it returns `undefined`.
      */
     getMinPathBetween(v1: VO | VertexKey, v2: VO | VertexKey, isWeight?: boolean, isDFS?: boolean): VO[] | undefined;
-    /**
-     *  Dijkstra algorithm time: O(VE) space: O(VO + EO)
-     */
-    /**
-     * Time Complexity: O(V^2 + E) - Quadratic time in the worst case (no heap optimization).
-     * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
-     */
     /**
      * Time Complexity: O(V^2 + E) - Quadratic time in the worst case (no heap optimization).
      * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
@@ -256,18 +213,6 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * @returns The function `dijkstraWithoutHeap` returns an object of type `DijkstraResult<VO>`.
      */
     dijkstraWithoutHeap(src: VO | VertexKey, dest?: VO | VertexKey | undefined, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<VO>;
-    /**
-     *  Dijkstra algorithm time: O(logVE) space: O(VO + EO)
-     *
-     * Dijkstra's algorithm only solves the single-source shortest path problem, while the Bellman-Ford algorithm and Floyd-Warshall algorithm can address shortest paths between all pairs of nodes.
-     * Dijkstra's algorithm is suitable for graphs with non-negative edge weights, whereas the Bellman-Ford algorithm and Floyd-Warshall algorithm can handle negative-weight edgeMap.
-     * The time complexity of Dijkstra's algorithm and the Bellman-Ford algorithm depends on the size of the graph, while the time complexity of the Floyd-Warshall algorithm is O(VO^3), where VO is the number of nodes. For dense graphs, Floyd-Warshall might become slower.
-     *
-     */
-    /**
-     * Time Complexity: O((V + E) * log(V)) - Depends on the implementation (using a binary heap).
-     * Space Complexity: O(V + E) - Depends on the implementation (using a binary heap).
-     */
     /**
      * Time Complexity: O((V + E) * log(V)) - Depends on the implementation (using a binary heap).
      * Space Complexity: O(V + E) - Depends on the implementation (using a binary heap).
@@ -289,11 +234,6 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * @returns The function `dijkstra` returns an object of type `DijkstraResult<VO>`.
      */
     dijkstra(src: VO | VertexKey, dest?: VO | VertexKey | undefined, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<VO>;
-    /**
-     * Time Complexity: O(V * E) - Quadratic time in the worst case (Bellman-Ford algorithm).
-     * Space Complexity: O(V + E) - Depends on the implementation (Bellman-Ford algorithm).
-     * one to rest pairs
-     */
     /**
      * Time Complexity: O(V * E) - Quadratic time in the worst case (Bellman-Ford algorithm).
      * Space Complexity: O(V + E) - Depends on the implementation (Bellman-Ford algorithm).
@@ -333,13 +273,6 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * The Bellman-Ford algorithm is also used to find the shortest paths from a source node to all other nodes in a graph. Unlike Dijkstra's algorithm, it can handle edge weights that are negative. Its basic idea involves iterative relaxation of all edgeMap for several rounds to gradually approximate the shortest paths. Due to its ability to handle negative-weight edgeMap, the Bellman-Ford algorithm is more flexible in some scenarios.
      * The `bellmanFord` function implements the Bellman-Ford algorithm to find the shortest path from a source vertex to
      */
-    /**
-     * Time Complexity: O(V^3) - Cubic time (Floyd-Warshall algorithm).
-     * Space Complexity: O(V^2) - Quadratic space (Floyd-Warshall algorithm).
-     * Not support graph with negative weight cycle
-     * all pairs
-     * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edgeMap, and it can simultaneously compute shortest paths between any two nodes.
-     */
     /**
      * Time Complexity: O(V^3) - Cubic time (Floyd-Warshall algorithm).
      * Space Complexity: O(V^2) - Quadratic space (Floyd-Warshall algorithm).
@@ -363,10 +296,6 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * O(V+C)
      */
     getCycles(isInclude2Cycle?: boolean): VertexKey[][];
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -384,10 +313,6 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * that satisfy the given predicate function.
      */
     filter(predicate: EntryCallback<VertexKey, V | undefined, boolean>, thisArg?: any): [VertexKey, V | undefined][];
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

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

@@ -53,10 +53,6 @@ export class AbstractGraph extends IterableEntryBase {
     get size() {
         return this._vertexMap.size;
     }
-    /**
-     * Time Complexity: O(1) - Constant time for Map lookup.
-     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
-     */
     /**
      * Time Complexity: O(1) - Constant time for Map lookup.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
@@ -70,10 +66,6 @@ export class AbstractGraph extends IterableEntryBase {
     getVertex(vertexKey) {
         return this._vertexMap.get(vertexKey) || undefined;
     }
-    /**
-     * Time Complexity: O(1) - Constant time for Map lookup.
-     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
-     */
     /**
      * Time Complexity: O(1) - Constant time for Map lookup.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
@@ -103,10 +95,6 @@ export class AbstractGraph extends IterableEntryBase {
         const potentialKeyType = typeof potentialKey;
         return potentialKeyType === 'string' || potentialKeyType === 'number';
     }
-    /**
-     * Time Complexity: O(K), where K is the number of vertexMap to be removed.
-     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
-     */
     /**
      * Time Complexity: O(K), where K is the number of vertexMap to be removed.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
@@ -124,10 +112,6 @@ export class AbstractGraph extends IterableEntryBase {
         }
         return removed.length > 0;
     }
-    /**
-     * Time Complexity: O(1) - Depends on the implementation in the concrete class.
-     * Space Complexity: O(1) - Depends on the implementation in the concrete class.
-     */
     /**
      * Time Complexity: O(1) - Depends on the implementation in the concrete class.
      * Space Complexity: O(1) - Depends on the implementation in the concrete class.
@@ -167,10 +151,6 @@ export class AbstractGraph extends IterableEntryBase {
             }
         }
     }
-    /**
-     * Time Complexity: O(1) - Constant time for Map and Edge operations.
-     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
-     */
     /**
      * Time Complexity: O(1) - Constant time for Map and Edge operations.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
@@ -195,10 +175,6 @@ export class AbstractGraph extends IterableEntryBase {
             return false;
         }
     }
-    /**
-     * Time Complexity: O(P), where P is the number of paths found (in the worst case, exploring all paths).
-     * Space Complexity: O(P) - Linear space, where P is the number of paths found.
-     */
     /**
      * Time Complexity: O(P), where P is the number of paths found (in the worst case, exploring all paths).
      * Space Complexity: O(P) - Linear space, where P is the number of paths found.
@@ -236,10 +212,6 @@ export class AbstractGraph extends IterableEntryBase {
         }
         return paths;
     }
-    /**
-     * Time Complexity: O(L), where L is the length of the path.
-     * Space Complexity: O(1) - Constant space.
-     */
     /**
      * Time Complexity: O(L), where L is the length of the path.
      * Space Complexity: O(1) - Constant space.
@@ -255,10 +227,6 @@ export class AbstractGraph extends IterableEntryBase {
         }
         return sum;
     }
-    /**
-     * Time Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
-     * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
-     */
     /**
      * Time Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
      * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
@@ -320,10 +288,6 @@ export class AbstractGraph extends IterableEntryBase {
             return undefined;
         }
     }
-    /**
-     * Time Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm or DFS).
-     * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm or DFS).
-     */
     /**
      * Time Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm or DFS).
      * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm or DFS).
@@ -393,13 +357,6 @@ export class AbstractGraph extends IterableEntryBase {
             return minPath;
         }
     }
-    /**
-     *  Dijkstra algorithm time: O(VE) space: O(VO + EO)
-     */
-    /**
-     * Time Complexity: O(V^2 + E) - Quadratic time in the worst case (no heap optimization).
-     * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
-     */
     /**
      * Time Complexity: O(V^2 + E) - Quadratic time in the worst case (no heap optimization).
      * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
@@ -515,18 +472,6 @@ export class AbstractGraph extends IterableEntryBase {
         genPaths && getPaths(minDest);
         return { distMap, preMap, seen, paths, minDist, minPath };
     }
-    /**
-     *  Dijkstra algorithm time: O(logVE) space: O(VO + EO)
-     *
-     * Dijkstra's algorithm only solves the single-source shortest path problem, while the Bellman-Ford algorithm and Floyd-Warshall algorithm can address shortest paths between all pairs of nodes.
-     * Dijkstra's algorithm is suitable for graphs with non-negative edge weights, whereas the Bellman-Ford algorithm and Floyd-Warshall algorithm can handle negative-weight edgeMap.
-     * The time complexity of Dijkstra's algorithm and the Bellman-Ford algorithm depends on the size of the graph, while the time complexity of the Floyd-Warshall algorithm is O(VO^3), where VO is the number of nodes. For dense graphs, Floyd-Warshall might become slower.
-     *
-     */
-    /**
-     * Time Complexity: O((V + E) * log(V)) - Depends on the implementation (using a binary heap).
-     * Space Complexity: O(V + E) - Depends on the implementation (using a binary heap).
-     */
     /**
      * Time Complexity: O((V + E) * log(V)) - Depends on the implementation (using a binary heap).
      * Space Complexity: O(V + E) - Depends on the implementation (using a binary heap).
@@ -642,11 +587,6 @@ export class AbstractGraph extends IterableEntryBase {
         }
         return { distMap, preMap, seen, paths, minDist, minPath };
     }
-    /**
-     * Time Complexity: O(V * E) - Quadratic time in the worst case (Bellman-Ford algorithm).
-     * Space Complexity: O(V + E) - Depends on the implementation (Bellman-Ford algorithm).
-     * one to rest pairs
-     */
     /**
      * Time Complexity: O(V * E) - Quadratic time in the worst case (Bellman-Ford algorithm).
      * Space Complexity: O(V + E) - Depends on the implementation (Bellman-Ford algorithm).
@@ -763,13 +703,6 @@ export class AbstractGraph extends IterableEntryBase {
      * The Bellman-Ford algorithm is also used to find the shortest paths from a source node to all other nodes in a graph. Unlike Dijkstra's algorithm, it can handle edge weights that are negative. Its basic idea involves iterative relaxation of all edgeMap for several rounds to gradually approximate the shortest paths. Due to its ability to handle negative-weight edgeMap, the Bellman-Ford algorithm is more flexible in some scenarios.
      * The `bellmanFord` function implements the Bellman-Ford algorithm to find the shortest path from a source vertex to
      */
-    /**
-     * Time Complexity: O(V^3) - Cubic time (Floyd-Warshall algorithm).
-     * Space Complexity: O(V^2) - Quadratic space (Floyd-Warshall algorithm).
-     * Not support graph with negative weight cycle
-     * all pairs
-     * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edgeMap, and it can simultaneously compute shortest paths between any two nodes.
-     */
     /**
      * Time Complexity: O(V^3) - Cubic time (Floyd-Warshall algorithm).
      * Space Complexity: O(V^2) - Quadratic space (Floyd-Warshall algorithm).
@@ -853,10 +786,6 @@ export class AbstractGraph extends IterableEntryBase {
         // Convert the unique cycles back to an array
         return [...uniqueCycles].map(cycleString => cycleString[1]);
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -884,10 +813,6 @@ export class AbstractGraph extends IterableEntryBase {
         }
         return filtered;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)