undirected-graph-typed 1.49.0 → 1.49.1

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

@@ -58,7 +58,7 @@ class BST extends binary_tree_1.BinaryTree {
     /**
      * This is the constructor function for a binary search tree class in TypeScript, which initializes
      * the tree with optional elements and options.
-     * @param [elements] - An optional iterable of BTNodeExemplar objects that will be added to the
+     * @param [elements] - An optional iterable of BTNExemplar objects that will be added to the
      * binary search tree.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary search tree. It can have the following properties:
@@ -105,7 +105,7 @@ class BST extends binary_tree_1.BinaryTree {
     }
     /**
      * The function checks if an exemplar is an instance of BSTNode.
-     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<K, V, N>`.
+     * @param exemplar - The `exemplar` parameter is a variable of type `BTNExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the BSTNode class.
      */
     isNode(exemplar) {
@@ -114,7 +114,7 @@ class BST extends binary_tree_1.BinaryTree {
     /**
      * The function `exemplarToNode` takes an exemplar and returns a node if the exemplar is valid,
      * otherwise it returns undefined.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where:
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, where:
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
      * `exemplarToNode` function. It represents the value associated with the exemplar node.
      * @returns a node of type N or undefined.

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { BiTreeDeleteResult, BTNCallback, BTNodeExemplar, BTNodeKeyOrNode, IterationType, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
+import { BinaryTreeDeleteResult, BTNCallback, BTNExemplar, BTNKeyOrNode, IterationType, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 export declare class RedBlackTreeNode<K = any, V = any, N extends RedBlackTreeNode<K, V, N> = RedBlackTreeNodeNested<K, V>> extends BSTNode<K, V, N> {
@@ -24,7 +24,7 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
      * initializes the tree with optional elements and options.
-     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<K, V, N>`
+     * @param [elements] - The `elements` parameter is an optional iterable of `BTNExemplar<K, V, N>`
      * objects. It represents the initial elements that will be added to the RBTree during its
      * construction. If this parameter is provided, the `addMany` method is called to add all the
      * elements to the
@@ -32,7 +32,7 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * behavior of the RBTree. It is of type `Partial<RBTreeOptions>`, which means that you can provide
      * only a subset of the properties defined in the `RBTreeOptions` interface.
      */
-    constructor(elements?: Iterable<BTNodeExemplar<K, V, N>>, options?: Partial<RBTreeOptions<K>>);
+    constructor(elements?: Iterable<BTNExemplar<K, V, N>>, options?: Partial<RBTreeOptions<K>>);
     protected _root: N;
     get root(): N;
     protected _size: number;
@@ -60,27 +60,27 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
     createTree(options?: RBTreeOptions<K>): TREE;
     /**
      * The function checks if an exemplar is an instance of the RedBlackTreeNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the RedBlackTreeNode
      * class.
      */
-    isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N;
+    isNode(exemplar: BTNExemplar<K, V, N>): exemplar is N;
     /**
      * The function "isNotNodeInstance" checks if a potential key is a K.
      * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
      * data type.
      * @returns a boolean value indicating whether the potentialKey is of type number or not.
      */
-    isNotNodeInstance(potentialKey: BTNodeKeyOrNode<K, N>): potentialKey is K;
+    isNotNodeInstance(potentialKey: BTNKeyOrNode<K, N>): potentialKey is K;
     /**
      * The function `exemplarToNode` takes an exemplar and converts it into a node object if possible.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where:
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, where:
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
      * `exemplarToNode` function. It represents the value associated with the exemplar node. If a value
      * is provided, it will be used when creating the new node. If no value is provided, the new node
      * @returns a node of type N or undefined.
      */
-    exemplarToNode(exemplar: BTNodeExemplar<K, V, N>, value?: V): N | undefined;
+    exemplarToNode(exemplar: BTNExemplar<K, V, N>, value?: V): N | undefined;
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)
@@ -97,7 +97,7 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * being added to the binary search tree.
      * @returns The method `add` returns either the newly added node (`N`) or `undefined`.
      */
-    add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, value?: V): N | undefined;
+    add(keyOrNodeOrEntry: BTNExemplar<K, V, N>, value?: V): N | undefined;
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)
@@ -115,9 +115,9 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * @param {C} callback - The `callback` parameter is a function that takes a node of type `N` and
      * returns a value of type `ReturnType<C>`. It is used to determine if a node should be deleted based
      * on its identifier. The `callback` function is optional and defaults to `this._defaultOneParam
-     * @returns an array of `BiTreeDeleteResult<N>`.
+     * @returns an array of `BinaryTreeDeleteResult<N>`.
      */
-    delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null | undefined, callback?: C): BiTreeDeleteResult<N>[];
+    delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null | undefined, callback?: C): BinaryTreeDeleteResult<N>[];
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)

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

@@ -10,7 +10,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedBlackTree = exports.RedBlackTreeNode = void 0;
 const types_1 = require("../../types");
 const bst_1 = require("./bst");
-const binary_tree_1 = require("./binary-tree");
 class RedBlackTreeNode extends bst_1.BSTNode {
     constructor(key, value, color = types_1.RBTNColor.BLACK) {
         super(key, value);
@@ -29,7 +28,7 @@ class RedBlackTree extends bst_1.BST {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
      * initializes the tree with optional elements and options.
-     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<K, V, N>`
+     * @param [elements] - The `elements` parameter is an optional iterable of `BTNExemplar<K, V, N>`
      * objects. It represents the initial elements that will be added to the RBTree during its
      * construction. If this parameter is provided, the `addMany` method is called to add all the
      * elements to the
@@ -78,7 +77,7 @@ class RedBlackTree extends bst_1.BST {
     }
     /**
      * The function checks if an exemplar is an instance of the RedBlackTreeNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the RedBlackTreeNode
      * class.
      */
@@ -96,7 +95,7 @@ class RedBlackTree extends bst_1.BST {
     }
     /**
      * The function `exemplarToNode` takes an exemplar and converts it into a node object if possible.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where:
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, where:
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
      * `exemplarToNode` function. It represents the value associated with the exemplar node. If a value
      * is provided, it will be used when creating the new node. If no value is provided, the new node
@@ -207,7 +206,7 @@ class RedBlackTree extends bst_1.BST {
      * @param {C} callback - The `callback` parameter is a function that takes a node of type `N` and
      * returns a value of type `ReturnType<C>`. It is used to determine if a node should be deleted based
      * on its identifier. The `callback` function is optional and defaults to `this._defaultOneParam
-     * @returns an array of `BiTreeDeleteResult<N>`.
+     * @returns an array of `BinaryTreeDeleteResult<N>`.
      */
     delete(identifier, callback = this._defaultOneParamCallback) {
         const ans = [];
@@ -303,7 +302,7 @@ class RedBlackTree extends bst_1.BST {
      */
     getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         var _a;
-        if (identifier instanceof binary_tree_1.BinaryTreeNode)
+        if (identifier instanceof RedBlackTreeNode)
             callback = (node => node);
         beginRoot = this.ensureNode(beginRoot);
         return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : undefined;

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

@@ -5,8 +5,8 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BSTNodeKeyOrNode, BTNodeExemplar, TreeMultimapNodeNested, TreeMultimapOptions } from '../../types';
-import { BiTreeDeleteResult, BTNCallback, BTNodeKeyOrNode, IterationType, TreeMultimapNested } from '../../types';
+import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, BTNExemplar, BTNKeyOrNode, TreeMultimapNested, TreeMultimapNodeNested, TreeMultimapOptions } from '../../types';
+import { IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class TreeMultimapNode<K = any, V = any, N extends TreeMultimapNode<K, V, N> = TreeMultimapNodeNested<K, V>> extends AVLTreeNode<K, V, N> {
@@ -27,7 +27,7 @@ export declare class TreeMultimapNode<K = any, V = any, N extends TreeMultimapNo
  * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
 export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K, V, N> = TreeMultimapNode<K, V, TreeMultimapNodeNested<K, V>>, TREE extends TreeMultimap<K, V, N, TREE> = TreeMultimap<K, V, N, TreeMultimapNested<K, V, N>>> extends AVLTree<K, V, N, TREE> implements IBinaryTree<K, V, N, TREE> {
-    constructor(elements?: Iterable<BTNodeExemplar<K, V, N>>, options?: Partial<TreeMultimapOptions<K>>);
+    constructor(elements?: Iterable<BTNExemplar<K, V, N>>, options?: Partial<TreeMultimapOptions<K>>);
     private _count;
     get count(): number;
     /**
@@ -43,21 +43,21 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
     createTree(options?: TreeMultimapOptions<K>): TREE;
     /**
      * The function checks if an exemplar is an instance of the TreeMultimapNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the TreeMultimapNode
      * class.
      */
-    isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N;
+    isNode(exemplar: BTNExemplar<K, V, N>): exemplar is N;
     /**
      * The function "isNotNodeInstance" checks if a potential key is a K.
      * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
      * data type.
      * @returns a boolean value indicating whether the potentialKey is of type number or not.
      */
-    isNotNodeInstance(potentialKey: BTNodeKeyOrNode<K, N>): potentialKey is K;
+    isNotNodeInstance(potentialKey: BTNKeyOrNode<K, N>): potentialKey is K;
     /**
      * The function `exemplarToNode` converts an exemplar object into a node object.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, which means it
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, which means it
      * can be one of the following:
      * @param {V} [value] - The `value` parameter is an optional argument that represents the value
      * associated with the node. It is of type `V`, which can be any data type. If no value is provided,
@@ -66,7 +66,7 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * times the value should be added to the node. If not provided, it defaults to 1.
      * @returns a node of type `N` or `undefined`.
      */
-    exemplarToNode(exemplar: BTNodeExemplar<K, V, N>, value?: V, count?: number): N | undefined;
+    exemplarToNode(exemplar: BTNExemplar<K, V, N>, value?: V, count?: number): N | undefined;
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -87,7 +87,7 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * @returns The method is returning either the newly inserted node or `undefined` if the insertion
      * was not successful.
      */
-    add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, value?: V, count?: number): N | undefined;
+    add(keyOrNodeOrEntry: BTNExemplar<K, V, N>, value?: V, count?: number): N | undefined;
     /**
      * Time Complexity: O(k log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -102,7 +102,7 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * either keys, nodes, or entries.
      * @returns The method is returning an array of type `N | undefined`.
      */
-    addMany(keysOrNodesOrEntries: Iterable<BTNodeExemplar<K, V, N>>): (N | undefined)[];
+    addMany(keysOrNodesOrEntries: Iterable<BTNExemplar<K, V, N>>): (N | undefined)[];
     /**
      * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
      * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
@@ -140,9 +140,9 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * being deleted. If set to true, the count of the node will not be considered and the node will be
      * deleted regardless of its count. If set to false (default), the count of the node will be
      * decremented by 1 and
-     * @returns an array of `BiTreeDeleteResult<N>`.
+     * @returns an array of `BinaryTreeDeleteResult<N>`.
      */
-    delete<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback?: C, ignoreCount?: boolean): BiTreeDeleteResult<N>[];
+    delete<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback?: C, ignoreCount?: boolean): BinaryTreeDeleteResult<N>[];
     /**
      * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
      * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
@@ -178,7 +178,7 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * @returns The method `_addTo` returns either the `parent.left` or `parent.right` node that was
      * added, or `undefined` if no node was added.
      */
-    protected _addTo(newNode: N | undefined, parent: BSTNodeKeyOrNode<K, N>): N | undefined;
+    protected _addTo(newNode: N | undefined, parent: BSTNKeyOrNode<K, N>): N | undefined;
     /**
      * The `_swapProperties` function swaps the key, value, count, and height properties between two nodes.
      * @param {K | N | undefined} srcNode - The `srcNode` parameter represents the source node from
@@ -188,6 +188,6 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
      * if either `srcNode` or `destNode` is undefined.
      */
-    protected _swapProperties(srcNode: BSTNodeKeyOrNode<K, N>, destNode: BSTNodeKeyOrNode<K, N>): N | undefined;
+    protected _swapProperties(srcNode: BSTNKeyOrNode<K, N>, destNode: BSTNKeyOrNode<K, N>): N | undefined;
     protected _replaceNode(oldNode: N, newNode: N): N;
 }

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

@@ -53,7 +53,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
     }
     /**
      * The function checks if an exemplar is an instance of the TreeMultimapNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the TreeMultimapNode
      * class.
      */
@@ -71,7 +71,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
     }
     /**
      * The function `exemplarToNode` converts an exemplar object into a node object.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, which means it
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, which means it
      * can be one of the following:
      * @param {V} [value] - The `value` parameter is an optional argument that represents the value
      * associated with the node. It is of type `V`, which can be any data type. If no value is provided,
@@ -225,7 +225,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
      * being deleted. If set to true, the count of the node will not be considered and the node will be
      * deleted regardless of its count. If set to false (default), the count of the node will be
      * decremented by 1 and
-     * @returns an array of `BiTreeDeleteResult<N>`.
+     * @returns an array of `BinaryTreeDeleteResult<N>`.
      */
     delete(identifier, callback = this._defaultOneParamCallback, ignoreCount = false) {
         var _a;

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

@@ -1,7 +1,13 @@
-import type { DijkstraResult, VertexKey } from '../../types';
-import { EntryCallback } from "../../types";
-import { IGraph } from '../../interfaces';
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+import type { DijkstraResult, EntryCallback, VertexKey } from '../../types';
 import { IterableEntryBase } from "../base";
+import { IGraph } from '../../interfaces';
 export declare abstract class AbstractVertex<V = any> {
     key: VertexKey;
     value: V | undefined;

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

@@ -1,17 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractGraph = exports.AbstractEdge = exports.AbstractVertex = void 0;
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
 const utils_1 = require("../../utils");
-const priority_queue_1 = require("../priority-queue");
-const queue_1 = require("../queue");
 const base_1 = require("../base");
+const heap_1 = require("../heap");
+const queue_1 = require("../queue");
 class AbstractVertex {
     /**
      * The function is a protected constructor that takes an key and an optional value as parameters.
@@ -440,13 +433,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
      * shortest paths from the source vertex to all other vertexMap in the graph. If `genPaths
      * @returns The function `dijkstraWithoutHeap` returns an object of type `DijkstraResult<VO>`.
      */
-    dijkstraWithoutHeap(src, dest, getMinDist, genPaths) {
-        if (getMinDist === undefined)
-            getMinDist = false;
-        if (genPaths === undefined)
-            genPaths = false;
-        if (dest === undefined)
-            dest = undefined;
+    dijkstraWithoutHeap(src, dest = undefined, getMinDist = false, genPaths = false) {
         let minDist = Infinity;
         let minDest = undefined;
         let minPath = [];
@@ -575,14 +562,8 @@ class AbstractGraph extends base_1.IterableEntryBase {
      * shortest paths from the source vertex to all other vertexMap in the graph. If `genPaths
      * @returns The function `dijkstra` returns an object of type `DijkstraResult<VO>`.
      */
-    dijkstra(src, dest, getMinDist, genPaths) {
+    dijkstra(src, dest = undefined, getMinDist = false, genPaths = false) {
         var _a;
-        if (getMinDist === undefined)
-            getMinDist = false;
-        if (genPaths === undefined)
-            genPaths = false;
-        if (dest === undefined)
-            dest = undefined;
         let minDist = Infinity;
         let minDest = undefined;
         let minPath = [];
@@ -600,7 +581,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
             if (vertexOrKey instanceof AbstractVertex)
                 distMap.set(vertexOrKey, Infinity);
         }
-        const heap = new priority_queue_1.PriorityQueue([], { comparator: (a, b) => a.key - b.key });
+        const heap = new heap_1.Heap([], { comparator: (a, b) => a.key - b.key });
         heap.add({ key: 0, value: srcVertex });
         distMap.set(srcVertex, 0);
         preMap.set(srcVertex, undefined);
@@ -969,13 +950,28 @@ class AbstractGraph extends base_1.IterableEntryBase {
         }
         const cycles = new Map();
         if (needCycles) {
-            let SCCs = new Map();
-            if (SCCs.size < 1) {
-                SCCs = getSCCs();
-            }
-            SCCs.forEach((SCC, low) => {
-                if (SCC.length > 1) {
-                    cycles.set(low, SCC);
+            const visitedMap = new Map();
+            const stack = [];
+            const findCyclesDFS = (cur, parent) => {
+                visitedMap.set(cur, true);
+                stack.push(cur);
+                const neighbors = this.getNeighbors(cur);
+                for (const neighbor of neighbors) {
+                    if (!visitedMap.get(neighbor)) {
+                        findCyclesDFS(neighbor, cur);
+                    }
+                    else if (stack.includes(neighbor) && neighbor !== parent) {
+                        const cycleStartIndex = stack.indexOf(neighbor);
+                        const cycle = stack.slice(cycleStartIndex);
+                        const cycleLow = Math.min(...cycle.map(v => dfnMap.get(v) || Infinity));
+                        cycles.set(cycleLow, cycle);
+                    }
+                }
+                stack.pop();
+            };
+            vertexMap.forEach(v => {
+                if (!visitedMap.get(v)) {
+                    findCyclesDFS(v, undefined);
                 }
             });
         }

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

@@ -1,5 +1,12 @@
-import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
 import type { VertexKey } from '../../types';
+import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
 import { IGraph } from '../../interfaces';
 export declare class DirectedVertex<V = any> extends AbstractVertex<V> {
     /**

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

@@ -1,15 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DirectedGraph = exports.DirectedEdge = exports.DirectedVertex = void 0;
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-const utils_1 = require("../../utils");
 const abstract_graph_1 = require("./abstract-graph");
+const utils_1 = require("../../utils");
 class DirectedVertex extends abstract_graph_1.AbstractVertex {
     /**
      * The constructor function initializes a vertex with an optional value.

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

@@ -1,4 +1,4 @@
-import { MapGraphCoordinate, VertexKey } from '../../types';
+import type { MapGraphCoordinate, VertexKey } from '../../types';
 import { DirectedEdge, DirectedGraph, DirectedVertex } from './directed-graph';
 export declare class MapVertex<V = any> extends DirectedVertex<V> {
     lat: number;

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

@@ -1,6 +1,13 @@
-import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
 import type { VertexKey } from '../../types';
 import { IGraph } from '../../interfaces';
+import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
 export declare class UndirectedVertex<V = any> extends AbstractVertex<V> {
     /**
      * The constructor function initializes a vertex with an optional value.

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

@@ -1,15 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UndirectedGraph = exports.UndirectedEdge = exports.UndirectedVertex = void 0;
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-const utils_1 = require("../../utils");
 const abstract_graph_1 = require("./abstract-graph");
+const utils_1 = require("../../utils");
 class UndirectedVertex extends abstract_graph_1.AbstractVertex {
     /**
      * The constructor function initializes a vertex with an optional value.

package/dist/data-structures/hash/hash-map.d.ts

@@ -5,8 +5,14 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { EntryCallback, HashMapLinkedNode, HashMapOptions, HashMapStoreItem } from '../../types';
-import { IterableEntryBase } from "../base";
+import type { EntryCallback, HashMapLinkedNode, HashMapOptions, HashMapStoreItem } from '../../types';
+import { IterableEntryBase } from '../base';
+/**
+ * 1. Key-Value Pair Storage: HashMap stores key-value pairs. Each key maps to a value.
+ * 2. Fast Lookup: It's used when you need to quickly find, insert, or delete elements based on a key.
+ * 3. Unique Keys: Keys are unique. If you try to insert another entry with the same key, the old entry will be replaced by the new one.
+ * 4. Unordered Collection: HashMap does not guarantee the order of elements, and the order may change over time.
+ */
 export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     protected _store: {
         [key: string]: HashMapStoreItem<K, V>;
@@ -117,6 +123,11 @@ export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     protected _isObjKey(key: any): key is (object | ((...args: any[]) => any));
     protected _getNoObjKey(key: K): string;
 }
+/**
+ * 1. Maintaining the Order of Element Insertion: Unlike HashMap, LinkedHashMap maintains the order in which elements are inserted. Therefore, when you traverse it, elements will be returned in the order they were inserted into the map.
+ * 2. Based on Hash Table and Linked List: It combines the structures of a hash table and a linked list, using the hash table to ensure fast access, while maintaining the order of elements through the linked list.
+ * 3. Time Complexity: Similar to HashMap, LinkedHashMap offers constant-time performance for get and put operations in most cases.
+ */
 export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     protected _noObjMap: Record<string, HashMapLinkedNode<K, V | undefined>>;
     protected _objMap: WeakMap<object, HashMapLinkedNode<K, V | undefined>>;
@@ -169,6 +180,7 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      */
     set(key: K, value?: V): number;
     has(key: K): boolean;
+    hasValue(value: V): boolean;
     setMany(entries: Iterable<[K, V]>): void;
     /**
      * Time Complexity: O(1)

package/dist/data-structures/hash/hash-map.js

@@ -1,15 +1,14 @@
 "use strict";
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LinkedHashMap = exports.HashMap = void 0;
-const utils_1 = require("../../utils");
 const base_1 = require("../base");
+const utils_1 = require("../../utils");
+/**
+ * 1. Key-Value Pair Storage: HashMap stores key-value pairs. Each key maps to a value.
+ * 2. Fast Lookup: It's used when you need to quickly find, insert, or delete elements based on a key.
+ * 3. Unique Keys: Keys are unique. If you try to insert another entry with the same key, the old entry will be replaced by the new one.
+ * 4. Unordered Collection: HashMap does not guarantee the order of elements, and the order may change over time.
+ */
 class HashMap extends base_1.IterableEntryBase {
     /**
      * The constructor function initializes a new instance of a class with optional elements and options.
@@ -230,6 +229,11 @@ class HashMap extends base_1.IterableEntryBase {
     }
 }
 exports.HashMap = HashMap;
+/**
+ * 1. Maintaining the Order of Element Insertion: Unlike HashMap, LinkedHashMap maintains the order in which elements are inserted. Therefore, when you traverse it, elements will be returned in the order they were inserted into the map.
+ * 2. Based on Hash Table and Linked List: It combines the structures of a hash table and a linked list, using the hash table to ensure fast access, while maintaining the order of elements through the linked list.
+ * 3. Time Complexity: Similar to HashMap, LinkedHashMap offers constant-time performance for get and put operations in most cases.
+ */
 class LinkedHashMap extends base_1.IterableEntryBase {
     constructor(elements, options = {
         hashFn: (key) => String(key),
@@ -365,6 +369,13 @@ class LinkedHashMap extends base_1.IterableEntryBase {
             return hash in this._noObjMap;
         }
     }
+    hasValue(value) {
+        for (const [, elementValue] of this) {
+            if (elementValue === value)
+                return true;
+        }
+        return false;
+    }
     setMany(entries) {
         for (const entry of entries) {
             const [key, value] = entry;

package/dist/data-structures/hash/hash-table.d.ts

@@ -5,13 +5,13 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-export declare class HashTableNode<K, V> {
+import type { HashFunction } from '../../types';
+export declare class HashTableNode<K = any, V = any> {
     key: K;
     value: V;
     next: HashTableNode<K, V> | undefined;
     constructor(key: K, value: V);
 }
-import { HashFunction } from '../../types';
 export declare class HashTable<K = any, V = any> {
     protected static readonly DEFAULT_CAPACITY = 16;
     protected static readonly LOAD_FACTOR = 0.75;

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

@@ -4,9 +4,20 @@
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-import type { Comparator, DFSOrderPattern, ElementCallback } from '../../types';
-import { HeapOptions } from "../../types";
-import { IterableElementBase } from "../base";
+import type { Comparator, DFSOrderPattern, ElementCallback, HeapOptions } from '../../types';
+import { IterableElementBase } from '../base';
+/**
+ * 1. Complete Binary Tree: Heaps are typically complete binary trees, meaning every level is fully filled except possibly for the last level, which has nodes as far left as possible.
+ * 2. Heap Properties: Each node in a heap follows a specific order property, which varies depending on the type of heap:
+ * Max Heap: The value of each parent node is greater than or equal to the value of its children.
+ * Min Heap: The value of each parent node is less than or equal to the value of its children.
+ * 3. Root Node Access: In a heap, the largest element (in a max heap) or the smallest element (in a min heap) is always at the root of the tree.
+ * 4. Efficient Insertion and Deletion: Due to its structure, a heap allows for insertion and deletion operations in logarithmic time (O(log n)).
+ * 5. Managing Dynamic Data Sets: Heaps effectively manage dynamic data sets, especially when frequent access to the largest or smallest elements is required.
+ * 6. Non-linear Search: While a heap allows rapid access to its largest or smallest element, it is less efficient for other operations, such as searching for a specific element, as it is not designed for these tasks.
+ * 7. Efficient Sorting Algorithms: For example, heap sort. Heap sort uses the properties of a heap to sort elements.
+ * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.
+ */
 export declare class Heap<E = any> extends IterableElementBase<E> {
     options: HeapOptions<E>;
     constructor(elements?: Iterable<E>, options?: HeapOptions<E>);

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

@@ -8,6 +8,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FibonacciHeap = exports.FibonacciHeapNode = exports.Heap = void 0;
 const base_1 = require("../base");
+/**
+ * 1. Complete Binary Tree: Heaps are typically complete binary trees, meaning every level is fully filled except possibly for the last level, which has nodes as far left as possible.
+ * 2. Heap Properties: Each node in a heap follows a specific order property, which varies depending on the type of heap:
+ * Max Heap: The value of each parent node is greater than or equal to the value of its children.
+ * Min Heap: The value of each parent node is less than or equal to the value of its children.
+ * 3. Root Node Access: In a heap, the largest element (in a max heap) or the smallest element (in a min heap) is always at the root of the tree.
+ * 4. Efficient Insertion and Deletion: Due to its structure, a heap allows for insertion and deletion operations in logarithmic time (O(log n)).
+ * 5. Managing Dynamic Data Sets: Heaps effectively manage dynamic data sets, especially when frequent access to the largest or smallest elements is required.
+ * 6. Non-linear Search: While a heap allows rapid access to its largest or smallest element, it is less efficient for other operations, such as searching for a specific element, as it is not designed for these tasks.
+ * 7. Efficient Sorting Algorithms: For example, heap sort. Heap sort uses the properties of a heap to sort elements.
+ * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.
+ */
 class Heap extends base_1.IterableElementBase {
     constructor(elements, options) {
         super();