graph-typed 1.48.9 → 1.49.1

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

@@ -7,11 +7,12 @@
  */
 import type {
   BSTNested,
-  BSTNodeKeyOrNode,
+  BSTNKeyOrNode,
   BSTNodeNested,
   BSTOptions,
   BTNCallback,
-  BTNodeExemplar,
+  BTNExemplar,
+  BTNKeyOrNode,
   BTNodePureExemplar
 } from '../../types';
 import { BSTVariant, CP, IterationType } from '../../types';
@@ -87,12 +88,12 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
   /**
    * 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:
    */
-  constructor(elements?: Iterable<BTNodeExemplar<K, V, N>>, options?: Partial<BSTOptions<K>>) {
+  constructor(elements?: Iterable<BTNExemplar<K, V, N>>, options?: Partial<BSTOptions<K>>) {
     super([], options);
 
     if (options) {
@@ -147,10 +148,10 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
 
   /**
    * 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.
    */
-  override isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N {
+  override isNode(exemplar: BTNExemplar<K, V, N>): exemplar is N {
     return exemplar instanceof BSTNode;
   }
 
@@ -158,12 +159,12 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
   /**
    * 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.
    */
-  override exemplarToNode(exemplar: BTNodeExemplar<K, V, N>, value?: V): N | undefined {
+  override exemplarToNode(exemplar: BTNExemplar<K, V, N>, value?: V): N | undefined {
     let node: N | undefined;
     if (exemplar === null || exemplar === undefined) {
       return;
@@ -201,7 +202,7 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
    * @returns The method `add` returns either the newly added node (`newNode`) or `undefined` if the
    * node was not added.
    */
-  override add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, value?: V): N | undefined {
+  override add(keyOrNodeOrEntry: BTNExemplar<K, V, N>, value?: V): N | undefined {
     const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
     if (newNode === undefined) return;
 
@@ -273,7 +274,7 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
    * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
    */
   override addMany(
-    keysOrNodesOrEntries: Iterable<BTNodeExemplar<K, V, N>>,
+    keysOrNodesOrEntries: Iterable<BTNExemplar<K, V, N>>,
     values?: Iterable<V | undefined>,
     isBalanceAdd = true,
     iterationType = this.iterationType
@@ -297,7 +298,7 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
 
     const realBTNExemplars: BTNodePureExemplar<K, V, N>[] = [];
 
-    const isRealBTNExemplar = (kve: BTNodeExemplar<K, V, N>): kve is BTNodePureExemplar<K, V, N> => {
+    const isRealBTNExemplar = (kve: BTNExemplar<K, V, N>): kve is BTNodePureExemplar<K, V, N> => {
       if (kve === undefined || kve === null) return false;
       return !(this.isEntry(kve) && (kve[0] === undefined || kve[0] === null));
     }
@@ -379,7 +380,7 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
    * the key of the leftmost node if the comparison result is greater than, and the key of the
    * rightmost node otherwise. If no node is found, it returns 0.
    */
-  lastKey(beginRoot: BSTNodeKeyOrNode<K, N> = this.root): K | undefined {
+  lastKey(beginRoot: BSTNKeyOrNode<K, N> = this.root): K | undefined {
     let current = this.ensureNode(beginRoot);
     if (!current) return undefined;
 
@@ -442,6 +443,16 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
     }
   }
 
+  /**
+   * 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.
+   */
+  override isNotNodeInstance(potentialKey: BTNKeyOrNode<K, N>): potentialKey is K {
+    return !(potentialKey instanceof BSTNode)
+  }
+
   /**
    * Time Complexity: O(log n) - Average case for a balanced tree.
    * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -456,7 +467,7 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
    * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
    * @returns either a node object (N) or undefined.
    */
-  override ensureNode(key: BSTNodeKeyOrNode<K, N>, iterationType = IterationType.ITERATIVE): N | undefined {
+  override ensureNode(key: BSTNKeyOrNode<K, N>, iterationType = IterationType.ITERATIVE): N | undefined {
     return this.isNotNodeInstance(key) ? this.getNodeByKey(key, iterationType) : key;
   }
 
@@ -487,7 +498,7 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
     identifier: ReturnType<C> | undefined,
     callback: C = this._defaultOneParamCallback as C,
     onlyOne = false,
-    beginRoot: BSTNodeKeyOrNode<K, N> = this.root,
+    beginRoot: BSTNKeyOrNode<K, N> = this.root,
     iterationType = this.iterationType
   ): N[] {
     beginRoot = this.ensureNode(beginRoot);
@@ -568,7 +579,7 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
   lesserOrGreaterTraverse<C extends BTNCallback<N>>(
     callback: C = this._defaultOneParamCallback as C,
     lesserOrGreater: CP = CP.lt,
-    targetNode: BSTNodeKeyOrNode<K, N> = this.root,
+    targetNode: BSTNKeyOrNode<K, N> = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[] {
     targetNode = this.ensureNode(targetNode);

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

@@ -7,10 +7,11 @@
  */
 
 import {
-  BiTreeDeleteResult,
-  BSTNodeKeyOrNode,
+  BinaryTreeDeleteResult,
+  BSTNKeyOrNode,
   BTNCallback,
-  BTNodeExemplar,
+  BTNExemplar,
+  BTNKeyOrNode,
   IterationType,
   RBTNColor,
   RBTreeOptions,
@@ -19,7 +20,6 @@ import {
 } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
-import { BinaryTreeNode } from './binary-tree';
 
 export class RedBlackTreeNode<K = any, V = any, N extends RedBlackTreeNode<K, V, N> = RedBlackTreeNodeNested<K, V>> extends BSTNode<
   K, V,
@@ -48,7 +48,7 @@ export class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K, V, N>
   /**
    * 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
@@ -56,7 +56,7 @@ export class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K, V, N>
    * 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>>) {
     super([], options);
 
     this._root = this.Sentinel;
@@ -107,23 +107,33 @@ export class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K, V, N>
 
   /**
    * 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.
    */
-  override isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N {
+  override isNode(exemplar: BTNExemplar<K, V, N>): exemplar is N {
     return exemplar instanceof RedBlackTreeNode;
   }
 
+  /**
+   * 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.
+   */
+  override isNotNodeInstance(potentialKey: BTNKeyOrNode<K, N>): potentialKey is K {
+    return !(potentialKey instanceof RedBlackTreeNode)
+  }
+
   /**
    * 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.
    */
-  override exemplarToNode(exemplar: BTNodeExemplar<K, V, N>, value?: V): N | undefined {
+  override exemplarToNode(exemplar: BTNExemplar<K, V, N>, value?: V): N | undefined {
     let node: N | undefined;
 
     if (exemplar === null || exemplar === undefined) {
@@ -162,7 +172,7 @@ export class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K, V, N>
    * being added to the binary search tree.
    * @returns The method `add` returns either the newly added node (`N`) or `undefined`.
    */
-  override add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, value?: V): N | undefined {
+  override add(keyOrNodeOrEntry: BTNExemplar<K, V, N>, value?: V): N | undefined {
     const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
     if (newNode === undefined) return;
 
@@ -231,13 +241,13 @@ export class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K, V, N>
    * @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 = this._defaultOneParamCallback as C
-  ): BiTreeDeleteResult<N>[] {
-    const ans: BiTreeDeleteResult<N>[] = [];
+  ): BinaryTreeDeleteResult<N>[] {
+    const ans: BinaryTreeDeleteResult<N>[] = [];
     if (identifier === null) return ans;
     const helper = (node: N | undefined): void => {
       let z: N = this.Sentinel;
@@ -300,7 +310,8 @@ export class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K, V, N>
    */
 
   override isRealNode(node: N | undefined): node is N {
-    return node !== this.Sentinel && node !== undefined;
+    if (node === this.Sentinel || node === undefined) return false;
+    return node instanceof RedBlackTreeNode;
   }
 
   getNode<C extends BTNCallback<N, K>>(
@@ -353,47 +364,21 @@ export class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K, V, N>
   getNode<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | undefined,
     callback: C = this._defaultOneParamCallback as C,
-    beginRoot: BSTNodeKeyOrNode<K, N> = this.root,
+    beginRoot: BSTNKeyOrNode<K, N> = this.root,
     iterationType = this.iterationType
   ): N | null | undefined {
-    if ((identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
+    if ((identifier as any) instanceof RedBlackTreeNode) callback = (node => node) as C;
     beginRoot = this.ensureNode(beginRoot);
     return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
   }
 
   /**
-   * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-   * Space Complexity: O(1)
-   *
-   * The function returns the successor of a given node in a red-black tree.
-   * @param {RedBlackTreeNode} x - RedBlackTreeNode - The node for which we want to find the successor.
-   * @returns the successor of the given RedBlackTreeNode.
-   */
-  override getSuccessor(x: N): N | undefined {
-    if (x.right !== this.Sentinel) {
-      return this.getLeftMost(x.right) ?? undefined;
-    }
-
-    let y: N | undefined = x.parent;
-    while (y !== this.Sentinel && y !== undefined && x === y.right) {
-      x = y;
-      y = y.parent;
-    }
-    return y;
-  }
-
-  /**
-   * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+   * Time Complexity: O(log n)
    * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+   * Time Complexity: O(log n)
    * Space Complexity: O(1)
    *
    * The function returns the predecessor of a given node in a red-black tree.
@@ -402,12 +387,12 @@ export class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K, V, N>
    * @returns the predecessor of the given RedBlackTreeNode 'x'.
    */
   override getPredecessor(x: N): N {
-    if (x.left !== this.Sentinel) {
-      return this.getRightMost(x.left!)!;
+    if (this.isRealNode(x.left)) {
+      return this.getRightMost(x.left)!;
     }
 
     let y: N | undefined = x.parent;
-    while (y !== this.Sentinel && x === y!.left) {
+    while (this.isRealNode(y) && x === y.left) {
       x = y!;
       y = y!.parent;
     }

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

@@ -5,8 +5,17 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BSTNodeKeyOrNode, BTNodeExemplar, TreeMultimapNodeNested, TreeMultimapOptions } from '../../types';
-import { BiTreeDeleteResult, BTNCallback, FamilyPosition, IterationType, TreeMultimapNested } from '../../types';
+import type {
+  BinaryTreeDeleteResult,
+  BSTNKeyOrNode,
+  BTNCallback,
+  BTNExemplar,
+  BTNKeyOrNode,
+  TreeMultimapNested,
+  TreeMultimapNodeNested,
+  TreeMultimapOptions
+} from '../../types';
+import { FamilyPosition, IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 
@@ -41,7 +50,7 @@ export class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<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>>) {
     super([], options);
     if (elements) this.addMany(elements);
   }
@@ -77,18 +86,27 @@ export class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K, V, N>
 
   /**
    * 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.
    */
-  override isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N {
+  override isNode(exemplar: BTNExemplar<K, V, N>): exemplar is N {
     return exemplar instanceof TreeMultimapNode;
   }
 
+  /**
+   * 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.
+   */
+  override isNotNodeInstance(potentialKey: BTNKeyOrNode<K, N>): potentialKey is K {
+    return !(potentialKey instanceof TreeMultimapNode)
+  }
 
   /**
    * 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,
@@ -97,7 +115,7 @@ export class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K, V, N>
    * times the value should be added to the node. If not provided, it defaults to 1.
    * @returns a node of type `N` or `undefined`.
    */
-  override exemplarToNode(exemplar: BTNodeExemplar<K, V, N>, value?: V, count = 1): N | undefined {
+  override exemplarToNode(exemplar: BTNExemplar<K, V, N>, value?: V, count = 1): N | undefined {
     let node: N | undefined;
     if (exemplar === undefined || exemplar === null) {
       return;
@@ -139,7 +157,7 @@ export class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K, V, N>
    * @returns The method is returning either the newly inserted node or `undefined` if the insertion
    * was not successful.
    */
-  override add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, value?: V, count = 1): N | undefined {
+  override add(keyOrNodeOrEntry: BTNExemplar<K, V, N>, value?: V, count = 1): N | undefined {
     const newNode = this.exemplarToNode(keyOrNodeOrEntry, value, count);
     if (newNode === undefined) return;
 
@@ -166,7 +184,7 @@ export class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K, V, N>
    * either keys, nodes, or entries.
    * @returns The method is returning an array of type `N | undefined`.
    */
-  override addMany(keysOrNodesOrEntries: Iterable<BTNodeExemplar<K, V, N>>): (N | undefined)[] {
+  override addMany(keysOrNodesOrEntries: Iterable<BTNExemplar<K, V, N>>): (N | undefined)[] {
     return super.addMany(keysOrNodesOrEntries);
   }
 
@@ -246,14 +264,14 @@ export class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K, V, N>
    * 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>`.
    */
   override delete<C extends BTNCallback<N>>(
     identifier: ReturnType<C>,
     callback: C = this._defaultOneParamCallback as C,
     ignoreCount = false
-  ): BiTreeDeleteResult<N>[] {
-    const deletedResult: BiTreeDeleteResult<N>[] = [];
+  ): BinaryTreeDeleteResult<N>[] {
+    const deletedResult: BinaryTreeDeleteResult<N>[] = [];
     if (!this.root) return deletedResult;
 
     const curr: N | undefined = this.getNode(identifier, callback) ?? undefined;
@@ -354,7 +372,7 @@ export class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K, V, N>
    * @returns The method `_addTo` returns either the `parent.left` or `parent.right` node that was
    * added, or `undefined` if no node was added.
    */
-  protected override _addTo(newNode: N | undefined, parent: BSTNodeKeyOrNode<K, N>): N | undefined {
+  protected override _addTo(newNode: N | undefined, parent: BSTNKeyOrNode<K, N>): N | undefined {
     parent = this.ensureNode(parent);
     if (parent) {
       if (parent.left === undefined) {
@@ -389,7 +407,7 @@ export class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K, V, N>
    * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
    * if either `srcNode` or `destNode` is undefined.
    */
-  protected override _swapProperties(srcNode: BSTNodeKeyOrNode<K, N>, destNode: BSTNodeKeyOrNode<K, N>): N | undefined {
+  protected override _swapProperties(srcNode: BSTNKeyOrNode<K, N>, destNode: BSTNKeyOrNode<K, N>): N | undefined {
     srcNode = this.ensureNode(srcNode);
     destNode = this.ensureNode(destNode);
     if (srcNode && destNode) {

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

@@ -5,13 +5,12 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
+import type { DijkstraResult, EntryCallback, VertexKey } from '../../types';
 import { uuidV4 } from '../../utils';
-import { PriorityQueue } from '../priority-queue';
-import type { DijkstraResult, VertexKey } from '../../types';
-import { EntryCallback } from "../../types";
+import { IterableEntryBase } from "../base";
 import { IGraph } from '../../interfaces';
+import { Heap } from '../heap';
 import { Queue } from '../queue';
-import { IterableEntryBase } from "../base";
 
 export abstract class AbstractVertex<V = any> {
   key: VertexKey;
@@ -527,14 +526,10 @@ export abstract class AbstractGraph<
    */
   dijkstraWithoutHeap(
     src: VO | VertexKey,
-    dest?: VO | VertexKey | undefined,
-    getMinDist?: boolean,
-    genPaths?: boolean
+    dest: VO | VertexKey | undefined = undefined,
+    getMinDist: boolean = false,
+    genPaths: boolean = false
   ): DijkstraResult<VO> {
-    if (getMinDist === undefined) getMinDist = false;
-    if (genPaths === undefined) genPaths = false;
-
-    if (dest === undefined) dest = undefined;
     let minDist = Infinity;
     let minDest: VO | undefined = undefined;
     let minPath: VO[] = [];
@@ -675,14 +670,11 @@ export abstract class AbstractGraph<
    */
   dijkstra(
     src: VO | VertexKey,
-    dest?: VO | VertexKey | undefined,
-    getMinDist?: boolean,
-    genPaths?: boolean
+    dest: VO | VertexKey | undefined = undefined,
+    getMinDist: boolean = false,
+    genPaths: boolean = false
   ): DijkstraResult<VO> {
-    if (getMinDist === undefined) getMinDist = false;
-    if (genPaths === undefined) genPaths = false;
 
-    if (dest === undefined) dest = undefined;
     let minDist = Infinity;
     let minDest: VO | undefined = undefined;
     let minPath: VO[] = [];
@@ -702,7 +694,7 @@ export abstract class AbstractGraph<
       if (vertexOrKey instanceof AbstractVertex) distMap.set(vertexOrKey, Infinity);
     }
 
-    const heap = new PriorityQueue<{ key: number; value: VO }>([], { comparator: (a, b) => a.key - b.key });
+    const heap = new Heap<{ key: number; value: VO }>([], { comparator: (a, b) => a.key - b.key });
     heap.add({ key: 0, value: srcVertex });
 
     distMap.set(srcVertex, 0);
@@ -1094,15 +1086,33 @@ export abstract class AbstractGraph<
     }
 
     const cycles: Map<number, VO[]> = new Map();
+
     if (needCycles) {
-      let SCCs: Map<number, VO[]> = new Map();
-      if (SCCs.size < 1) {
-        SCCs = getSCCs();
-      }
+      const visitedMap: Map<VO, boolean> = new Map();
+      const stack: VO[] = [];
+      const findCyclesDFS = (cur: VO, parent: VO | undefined) => {
+        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();
+      };
 
-      SCCs.forEach((SCC, low) => {
-        if (SCC.length > 1) {
-          cycles.set(low, SCC);
+      vertexMap.forEach(v => {
+        if (!visitedMap.get(v)) {
+          findCyclesDFS(v, undefined);
         }
       });
     }

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

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

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

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

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

@@ -5,10 +5,10 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { arrayRemove } from '../../utils';
-import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
 import type { VertexKey } from '../../types';
 import { IGraph } from '../../interfaces';
+import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
+import { arrayRemove } from '../../utils';
 
 export class UndirectedVertex<V = any> extends AbstractVertex<V> {
   /**

package/src/data-structures/hash/hash-map.ts

@@ -5,11 +5,16 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-
+import type { EntryCallback, HashMapLinkedNode, HashMapOptions, HashMapStoreItem } from '../../types';
+import { IterableEntryBase } from '../base';
 import { isWeakKey, rangeCheck } from '../../utils';
-import { 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 class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
   protected _store: { [key: string]: HashMapStoreItem<K, V> } = {};
   protected _objMap: Map<object, V> = new Map();
@@ -248,6 +253,11 @@ export class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
   }
 }
 
+/**
+ * 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 class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
 
   protected _noObjMap: Record<string, HashMapLinkedNode<K, V | undefined>> = {};
@@ -401,6 +411,13 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     }
   }
 
+  hasValue(value: V): boolean {
+    for (const [, elementValue] of this) {
+      if (elementValue === value) return true;
+    }
+    return false;
+  }
+
   setMany(entries: Iterable<[K, V]>): void {
     for (const entry of entries) {
       const [key, value] = entry;

package/src/data-structures/hash/hash-table.ts

@@ -6,7 +6,9 @@
  * @license MIT License
  */
 
-export class HashTableNode<K, V> {
+import type { HashFunction } from '../../types';
+
+export class HashTableNode<K = any, V = any> {
   key: K;
   value: V;
   next: HashTableNode<K, V> | undefined;
@@ -18,8 +20,6 @@ export class HashTableNode<K, V> {
   }
 }
 
-import { HashFunction } from '../../types';
-
 export class HashTable<K = any, V = any> {
   protected static readonly DEFAULT_CAPACITY = 16;
   protected static readonly LOAD_FACTOR = 0.75;