min-heap-typed 1.50.2 → 1.50.4

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

@@ -0,0 +1,463 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+import type {
+  BinaryTreeDeleteResult,
+  BSTNKeyOrNode,
+  BTNCallback,
+  KeyOrNodeOrEntry,
+  TreeMultiMapNested,
+  TreeMultiMapNodeNested,
+  TreeMultiMapOptions
+} from '../../types';
+import { IterationType, RBTNColor } from '../../types';
+import { IBinaryTree } from '../../interfaces';
+import { RedBlackTree, RedBlackTreeNode } from './rb-tree';
+
+export class TreeMultiMapNode<
+  K = any,
+  V = any,
+  NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNodeNested<K, V>
+> extends RedBlackTreeNode<K, V, NODE> {
+  /**
+   * The constructor function initializes an instance of a class with a key, value, and count.
+   * @param {K} key - The key parameter is of type K, which represents the type of the key for the
+   * constructor. It is required and must be provided when creating an instance of the class.
+   * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
+   * value associated with the key in the constructor. If no value is provided, it will be `undefined`.
+   * @param [count=1] - The "count" parameter is an optional parameter that specifies the number of
+   * times the key-value pair should be repeated. If no value is provided for "count", it defaults to
+   * 1.
+   */
+  constructor(key: K, value?: V, count = 1) {
+    super(key, value);
+    this.count = count;
+  }
+
+  protected _count: number = 1;
+
+  /**
+   * The function returns the value of the private variable _count.
+   * @returns The count property of the object, which is of type number.
+   */
+  get count(): number {
+    return this._count;
+  }
+
+  /**
+   * The above function sets the value of the count property.
+   * @param {number} value - The value parameter is of type number, which means it can accept any
+   * numeric value.
+   */
+  set count(value: number) {
+    this._count = value;
+  }
+}
+
+export class TreeMultiMap<
+  K = any,
+  V = any,
+  NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNode<K, V, TreeMultiMapNodeNested<K, V>>,
+  TREE extends TreeMultiMap<K, V, NODE, TREE> = TreeMultiMap<K, V, NODE, TreeMultiMapNested<K, V, NODE>>
+>
+  extends RedBlackTree<K, V, NODE, TREE>
+  implements IBinaryTree<K, V, NODE, TREE> {
+  /**
+   * The constructor function initializes a new instance of the TreeMultiMap class with optional
+   * initial keys, nodes, or entries.
+   * @param keysOrNodesOrEntries - The `keysOrNodesOrEntries` parameter is an iterable object that can
+   * contain keys, nodes, or entries. It is used to initialize the TreeMultiMap with the provided keys,
+   * nodes, or entries.
+   * @param [options] - The `options` parameter is an optional object that can be passed to the
+   * constructor. It allows you to customize the behavior of the `TreeMultiMap` instance.
+   */
+  constructor(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, NODE>> = [], options?: TreeMultiMapOptions<K>) {
+    super([], options);
+    if (keysOrNodesOrEntries) this.addMany(keysOrNodesOrEntries);
+  }
+
+  protected _count = 0;
+
+  // TODO the _count is not accurate after nodes count modified
+  /**
+   * The function calculates the sum of the count property of all nodes in a tree structure.
+   * @returns the sum of the count property of all nodes in the tree.
+   */
+  get count(): number {
+    let sum = 0;
+    this.dfs(node => (sum += node.count));
+    return sum;
+    // return this._count;
+  }
+
+  /**
+   * The function creates a new TreeMultiMapNode object with the specified key, value, and count.
+   * @param {K} key - The key parameter represents the key of the node being created. It is of type K,
+   * which is a generic type that can be replaced with any specific type when using the function.
+   * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
+   * associated with the key in the node. It is of type `V`, which can be any data type.
+   * @param {number} [count] - The `count` parameter represents the number of occurrences of a
+   * key-value pair in the TreeMultiMap. It is an optional parameter, so if it is not provided, it will
+   * default to 1.
+   * @returns a new instance of the TreeMultiMapNode class, casted as NODE.
+   */
+  override createNode(key: K, value?: V, count?: number): NODE {
+    return new TreeMultiMapNode(key, value, count) as NODE;
+  }
+
+  /**
+   * The function creates a new instance of a TreeMultiMap with the specified options and returns it.
+   * @param [options] - The `options` parameter is an optional object that contains additional
+   * configuration options for creating the `TreeMultiMap`. It can include properties such as
+   * `keyComparator`, `valueComparator`, `allowDuplicates`, etc.
+   * @returns a new instance of the `TreeMultiMap` class, with the provided options merged with the
+   * existing `iterationType` option. The returned value is casted as `TREE`.
+   */
+  override createTree(options?: TreeMultiMapOptions<K>): TREE {
+    return new TreeMultiMap<K, V, NODE, TREE>([], {
+      iterationType: this.iterationType,
+      ...options
+    }) as TREE;
+  }
+
+  /**
+   * The function `keyValueOrEntryToNode` takes a key, value, and count and returns a node if the input
+   * is valid.
+   * @param keyOrNodeOrEntry - The parameter `keyOrNodeOrEntry` can be of type `KeyOrNodeOrEntry<K, V,
+   * NODE>`. It can accept three types of values:
+   * @param {V} [value] - The `value` parameter is an optional value of type `V`. It represents the
+   * value associated with a key in a key-value pair.
+   * @param [count=1] - The count parameter is an optional parameter that specifies the number of times
+   * the key-value pair should be added to the node. If not provided, it defaults to 1.
+   * @returns a NODE object or undefined.
+   */
+  override keyValueOrEntryToNode(
+    keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>,
+    value?: V,
+    count = 1
+  ): NODE | undefined {
+    let node: NODE | undefined;
+    if (keyOrNodeOrEntry === undefined || keyOrNodeOrEntry === null) {
+      return;
+    } else if (this.isNode(keyOrNodeOrEntry)) {
+      node = keyOrNodeOrEntry;
+    } else if (this.isEntry(keyOrNodeOrEntry)) {
+      const [key, value] = keyOrNodeOrEntry;
+      if (key === undefined || key === null) {
+        return;
+      } else {
+        node = this.createNode(key, value, count);
+      }
+    } else if (!this.isNode(keyOrNodeOrEntry)) {
+      node = this.createNode(keyOrNodeOrEntry, value, count);
+    } else {
+      return;
+    }
+    return node;
+  }
+
+  /**
+   * The function "isNode" checks if a given key, node, or entry is an instance of the TreeMultiMapNode
+   * class.
+   * @param keyOrNodeOrEntry - The parameter `keyOrNodeOrEntry` can be of type `KeyOrNodeOrEntry<K, V,
+   * NODE>`.
+   * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntry` is an instance
+   * of the `TreeMultiMapNode` class.
+   */
+  override isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntry is NODE {
+    return keyOrNodeOrEntry instanceof TreeMultiMapNode;
+  }
+
+  /**
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
+   *
+   * The function overrides the add method in TypeScript and adds a new node to the data structure.
+   * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can accept three types of values:
+   * @param {V} [value] - The `value` parameter represents the value associated with the key in the
+   * data structure.
+   * @param [count=1] - The `count` parameter represents the number of times the key-value pair should
+   * be added to the data structure. By default, it is set to 1, meaning that the key-value pair will
+   * be added once. However, you can specify a different value for `count` if you want to add
+   * @returns a boolean value.
+   */
+  override add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, value?: V, count = 1): boolean {
+    const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value, count);
+    if (newNode === undefined) return false;
+
+    const orgNodeCount = newNode?.count || 0;
+    const inserted = super.add(newNode);
+    if (inserted) {
+      this._count += orgNodeCount;
+    }
+    return true;
+  }
+
+  /**
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
+   *
+   * The `delete` function in a TypeScript class is used to delete nodes from a binary tree based on a
+   * given identifier, and it returns an array of results containing information about the deleted
+   * nodes.
+   * @param {ReturnType<C> | null | undefined} identifier - The identifier parameter is the value used
+   * to identify the node to be deleted. It can be of any type that is returned by the callback
+   * function. It can also be null or undefined if no node needs to be deleted.
+   * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` as
+   * input and returns a value of type `ReturnType<C>`. It is used to determine if a node matches the
+   * identifier for deletion. If no callback is provided, the `_defaultOneParamCallback` function is
+   * used
+   * @param [ignoreCount=false] - A boolean value indicating whether to ignore the count of the target
+   * node when performing deletion. If set to true, the count of the target node will not be considered
+   * and the node will be deleted regardless of its count. If set to false (default), the count of the
+   * target node will be decremented
+   * @returns an array of BinaryTreeDeleteResult<NODE> objects.
+   */
+  override delete<C extends BTNCallback<NODE>>(
+    identifier: ReturnType<C> | null | undefined,
+    callback: C = this._defaultOneParamCallback as C,
+    ignoreCount = false
+  ): BinaryTreeDeleteResult<NODE>[] {
+    const deleteResults: BinaryTreeDeleteResult<NODE>[] = [];
+    if (identifier === null) return deleteResults;
+
+    // Helper function to perform deletion
+    const deleteHelper = (node: NODE | undefined): void => {
+      // Initialize targetNode to the sentinel node
+      let targetNode: NODE = this._Sentinel;
+      let currentNode: NODE | undefined;
+
+      // Find the node to be deleted based on the identifier
+      while (node !== this._Sentinel) {
+        // Update targetNode if the current node matches the identifier
+        if (node && callback(node) === identifier) {
+          targetNode = node;
+        }
+
+        // Move to the right or left based on the comparison with the identifier
+        if (node && identifier && callback(node) <= identifier) {
+          node = node.right;
+        } else {
+          node = node?.left;
+        }
+      }
+
+      // If the target node is not found, decrement size and return
+      if (targetNode === this._Sentinel) {
+        return;
+      }
+
+      if (ignoreCount || targetNode.count <= 1) {
+        // Store the parent of the target node and its original color
+        let parentNode = targetNode;
+        let parentNodeOriginalColor: number = parentNode.color;
+
+        // Handle deletion based on the number of children of the target node
+        if (targetNode.left === this._Sentinel) {
+          // Target node has no left child - deletion case 1
+          currentNode = targetNode.right;
+          this._rbTransplant(targetNode, targetNode.right!);
+        } else if (targetNode.right === this._Sentinel) {
+          // Target node has no right child - deletion case 2
+          currentNode = targetNode.left;
+          this._rbTransplant(targetNode, targetNode.left!);
+        } else {
+          // Target node has both left and right children - deletion case 3
+          parentNode = this.getLeftMost(targetNode.right)!;
+          parentNodeOriginalColor = parentNode.color;
+          currentNode = parentNode.right;
+
+          if (parentNode.parent === targetNode) {
+            // Target node's right child becomes its parent's left child
+            currentNode!.parent = parentNode;
+          } else {
+            // Replace parentNode with its right child and update connections
+            this._rbTransplant(parentNode, parentNode.right!);
+            parentNode.right = targetNode.right;
+            parentNode.right!.parent = parentNode;
+          }
+
+          // Replace the target node with its in-order successor
+          this._rbTransplant(targetNode, parentNode);
+          parentNode.left = targetNode.left;
+          parentNode.left!.parent = parentNode;
+          parentNode.color = targetNode.color;
+        }
+
+        // Fix the Red-Black Tree properties after deletion
+        if (parentNodeOriginalColor === RBTNColor.BLACK) {
+          this._fixDelete(currentNode!);
+        }
+
+        // Decrement the size and store information about the deleted node
+        this._size--;
+        this._count -= targetNode.count;
+        deleteResults.push({ deleted: targetNode, needBalanced: undefined });
+      } else {
+        targetNode.count--;
+        this._count--;
+      }
+    };
+
+    // Call the helper function with the root of the tree
+    deleteHelper(this.root);
+
+    // Return the result array
+    return deleteResults;
+  }
+
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The "clear" function overrides the parent class's "clear" function and also resets the count to
+   * zero.
+   */
+  override clear() {
+    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)
+   *
+   * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
+   * tree using either a recursive or iterative approach.
+   * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+   * type of iteration to use when building the balanced binary search tree. It can have two possible
+   * values:
+   * @returns a boolean value.
+   */
+  override perfectlyBalance(iterationType = this.iterationType): boolean {
+    const sorted = this.dfs(node => node, 'in'),
+      n = sorted.length;
+    if (sorted.length < 1) return false;
+
+    this.clear();
+
+    if (iterationType === IterationType.RECURSIVE) {
+      const buildBalanceBST = (l: number, r: number) => {
+        if (l > r) return;
+        const m = l + Math.floor((r - l) / 2);
+        const midNode = sorted[m];
+        this.add(midNode.key, midNode.value, midNode.count);
+        buildBalanceBST(l, m - 1);
+        buildBalanceBST(m + 1, r);
+      };
+
+      buildBalanceBST(0, n - 1);
+      return true;
+    } else {
+      const stack: [[number, number]] = [[0, n - 1]];
+      while (stack.length > 0) {
+        const popped = stack.pop();
+        if (popped) {
+          const [l, r] = popped;
+          if (l <= r) {
+            const m = l + Math.floor((r - l) / 2);
+            const midNode = sorted[m];
+            this.add(midNode.key, midNode.value, midNode.count);
+            stack.push([m + 1, r]);
+            stack.push([l, m - 1]);
+          }
+        }
+      }
+      return true;
+    }
+  }
+
+  /**
+   * Time complexity: O(n)
+   * Space complexity: O(n)
+   */
+
+  /**
+   * Time complexity: O(n)
+   * Space complexity: O(n)
+   *
+   * The function overrides the clone method to create a deep copy of a tree object.
+   * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
+   */
+  override clone(): TREE {
+    const cloned = this.createTree();
+    this.bfs(node => cloned.add(node.key, node.value, node.count));
+    return cloned;
+  }
+
+  /**
+   * The function swaps the properties of two nodes in a binary search tree.
+   * @param srcNode - The source node that needs to be swapped with the destination node. It can be
+   * either a key or a node object.
+   * @param destNode - The `destNode` parameter is the node in the binary search tree where the
+   * properties will be swapped with the `srcNode`.
+   * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
+   * If both `srcNode` and `destNode` are valid nodes, the method swaps their `key`, `value`, `count`,
+   * and `color` properties. If the swapping is successful, the method returns the modified `destNode`.
+   * If either `srcNode` or `destNode` is
+   */
+  protected override _swapProperties(
+    srcNode: BSTNKeyOrNode<K, NODE>,
+    destNode: BSTNKeyOrNode<K, NODE>
+  ): NODE | undefined {
+    srcNode = this.ensureNode(srcNode);
+    destNode = this.ensureNode(destNode);
+    if (srcNode && destNode) {
+      const { key, value, count, color } = destNode;
+      const tempNode = this.createNode(key, value, count);
+      if (tempNode) {
+        tempNode.color = color;
+
+        destNode.key = srcNode.key;
+        destNode.value = srcNode.value;
+        destNode.count = srcNode.count;
+        destNode.color = srcNode.color;
+
+        srcNode.key = tempNode.key;
+        srcNode.value = tempNode.value;
+        srcNode.count = tempNode.count;
+        srcNode.color = tempNode.color;
+      }
+
+      return destNode;
+    }
+    return undefined;
+  }
+
+  /**
+   * The function replaces an old node with a new node and updates the count property of the new node.
+   * @param {NODE} oldNode - The `oldNode` parameter is of type `NODE` and represents the node that
+   * needs to be replaced in the data structure.
+   * @param {NODE} newNode - The `newNode` parameter is an object of type `NODE`.
+   * @returns The method is returning the result of calling the `_replaceNode` method from the
+   * superclass, after updating the `count` property of the `newNode` object.
+   */
+  protected _replaceNode(oldNode: NODE, newNode: NODE): NODE {
+    newNode.count = oldNode.count + newNode.count;
+    return super._replaceNode(oldNode, newNode);
+  }
+}

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

@@ -954,217 +954,6 @@ export abstract class AbstractGraph<
     return { costs, predecessor };
   }
 
-  /**
-   * Time Complexity: O(V + E) - Linear time (Tarjan's algorithm).
-   * Space Complexity: O(V) - Linear space (Tarjan's algorithm).
-   * Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
-   * Tarjan can find cycles in directed or undirected graph
-   * Tarjan can find the articulation points and bridges(critical edgeMap) of undirected graphs in linear time,
-   * Tarjan solve the bi-connected components of undirected graphs;
-   * Tarjan can find the SSC(strongly connected components), articulation points, and bridges of directed graphs.
-   * /
-
-   /**
-   * Time Complexity: O(V + E) - Linear time (Tarjan's algorithm).
-   * Space Complexity: O(V) - Linear space (Tarjan's algorithm).
-   *
-   * Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
-   * Tarjan can find cycles in directed or undirected graph
-   * Tarjan can find the articulation points and bridges(critical edgeMap) of undirected graphs in linear time,
-   * Tarjan solve the bi-connected components of undirected graphs;
-   * Tarjan can find the SSC(strongly connected components), articulation points, and bridges of directed graphs.
-   * The `tarjan` function is used to perform various graph analysis tasks such as finding articulation points, bridges,
-   * strongly connected components (SCCs), and cycles in a graph.
-   * @param {boolean} [needCutVertexes] - A boolean value indicating whether or not to calculate and return the
-   * articulation points in the graph. Articulation points are the vertexMap in a graph whose removal would increase the
-   * number of connected components in the graph.
-   * @param {boolean} [needBridges] - A boolean flag indicating whether the algorithm should find and return the bridges
-   * (edgeMap whose removal would increase the number of connected components in the graph).
-   * @param {boolean} [needSCCs] - A boolean value indicating whether the Strongly Connected Components (SCCs) of the
-   * graph are needed. If set to true, the function will calculate and return the SCCs of the graph. If set to false, the
-   * SCCs will not be calculated or returned.
-   * @param {boolean} [needCycles] - A boolean flag indicating whether the algorithm should find cycles in the graph. If
-   * set to true, the algorithm will return a map of cycles, where the keys are the low values of the SCCs and the values
-   * are arrays of vertexMap that form cycles within the SCCs.
-   * @returns The function `tarjan` returns an object with the following properties:
-   */
-  tarjan(
-    needCutVertexes: boolean = false,
-    needBridges: boolean = false,
-    needSCCs: boolean = true,
-    needCycles: boolean = false
-  ) {
-    // !! in undirected graph we will not let child visit parent when dfs
-    // !! articulation point(in dfs search tree not in graph): (cur !== root && cur.has(child)) && (low(child) >= dfn(cur)) || (cur === root && cur.children() >= 2)
-    // !! bridge: low(child) > dfn(cur)
-
-    const defaultConfig = false;
-    if (needCutVertexes === undefined) needCutVertexes = defaultConfig;
-    if (needBridges === undefined) needBridges = defaultConfig;
-    if (needSCCs === undefined) needSCCs = defaultConfig;
-    if (needCycles === undefined) needCycles = defaultConfig;
-
-    const dfnMap: Map<VO, number> = new Map();
-    const lowMap: Map<VO, number> = new Map();
-    const vertexMap = this._vertexMap;
-    vertexMap.forEach(v => {
-      dfnMap.set(v, -1);
-      lowMap.set(v, Infinity);
-    });
-
-    const [root] = vertexMap.values();
-
-    const cutVertexes: VO[] = [];
-    const bridges: EO[] = [];
-    let dfn = 0;
-    const dfs = (cur: VO, parent: VO | undefined) => {
-      dfn++;
-      dfnMap.set(cur, dfn);
-      lowMap.set(cur, dfn);
-
-      const neighbors = this.getNeighbors(cur);
-      let childCount = 0; // child in dfs tree not child in graph
-      for (const neighbor of neighbors) {
-        if (neighbor !== parent) {
-          if (dfnMap.get(neighbor) === -1) {
-            childCount++;
-            dfs(neighbor, cur);
-          }
-          const childLow = lowMap.get(neighbor);
-          const curLow = lowMap.get(cur);
-          // TODO after no-non-undefined-assertion not ensure the logic
-          if (curLow !== undefined && childLow !== undefined) {
-            lowMap.set(cur, Math.min(curLow, childLow));
-          }
-          const curFromMap = dfnMap.get(cur);
-          if (childLow !== undefined && curFromMap !== undefined) {
-            if (needCutVertexes) {
-              if ((cur === root && childCount >= 2) || (cur !== root && childLow >= curFromMap)) {
-                // todo not ensure the logic if (cur === root && childCount >= 2 || ((cur !== root) && (childLow >= curFromMap))) {
-                cutVertexes.push(cur);
-              }
-            }
-
-            if (needBridges) {
-              if (childLow > curFromMap) {
-                const edgeCurToNeighbor = this.getEdge(cur, neighbor);
-                if (edgeCurToNeighbor) {
-                  bridges.push(edgeCurToNeighbor);
-                }
-              }
-            }
-          }
-        }
-      }
-    };
-
-    dfs(root, undefined);
-
-    let SCCs: Map<number, VO[]> = new Map();
-
-    const getSCCs = () => {
-      const SCCs: Map<number, VO[]> = new Map();
-      lowMap.forEach((low, vertex) => {
-        if (!SCCs.has(low)) {
-          SCCs.set(low, [vertex]);
-        } else {
-          SCCs.get(low)?.push(vertex);
-        }
-      });
-      return SCCs;
-    };
-
-    if (needSCCs) {
-      SCCs = getSCCs();
-    }
-
-    const cycles: Map<number, VO[]> = new Map();
-
-    if (needCycles) {
-      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();
-      };
-
-      vertexMap.forEach(v => {
-        if (!visitedMap.get(v)) {
-          findCyclesDFS(v, undefined);
-        }
-      });
-    }
-
-    return { dfnMap, lowMap, bridges, cutVertexes, SCCs, cycles };
-  }
-
-  /**
-   * Time Complexity: O(V + E) - Depends on the implementation (Tarjan's algorithm).
-   * Space Complexity: O(V) - Depends on the implementation (Tarjan's algorithm).
-   */
-
-  /**
-   * Time Complexity: O(V + E) - Depends on the implementation (Tarjan's algorithm).
-   * Space Complexity: O(V) - Depends on the implementation (Tarjan's algorithm).
-   *
-   * The function returns a map that associates each vertex object with its corresponding depth-first
-   * number.
-   * @returns A Map object with keys of type VO and values of type number.
-   */
-  getDFNMap(): Map<VO, number> {
-    return this.tarjan(false, false, false, false).dfnMap;
-  }
-
-  /**
-   * The function returns a Map object that contains the low values of each vertex in a Tarjan
-   * algorithm.
-   * @returns The method `getLowMap()` is returning a `Map` object with keys of type `VO` and values of
-   * type `number`.
-   */
-  getLowMap(): Map<VO, number> {
-    return this.tarjan(false, false, false, false).lowMap;
-  }
-
-  /**
-   * The function "getCutVertexes" returns an array of cut vertexes using the Tarjan algorithm.
-   * @returns an array of VO objects, specifically the cut vertexes.
-   */
-  getCutVertexes(): VO[] {
-    return this.tarjan(true, false, false, false).cutVertexes;
-  }
-
-  /**
-   * The function "getSCCs" returns a map of strongly connected components (SCCs) using the Tarjan
-   * algorithm.
-   * @returns a map where the keys are numbers and the values are arrays of VO objects.
-   */
-  getSCCs(): Map<number, VO[]> {
-    return this.tarjan(false, false, true, false).SCCs;
-  }
-
-  /**
-   * The function "getBridges" returns an array of bridges using the Tarjan algorithm.
-   * @returns the bridges found using the Tarjan algorithm.
-   */
-  getBridges() {
-    return this.tarjan(false, true, false, false).bridges;
-  }
-
   /**
    * O(V+E+C)
    * O(V+C)