data-structure-typed 1.47.6 → 1.47.8

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

@@ -1,4 +1,4 @@
-import { CP, FamilyPosition, IterationType } from '../../types';
+import { FamilyPosition, IterationType } from '../../types';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export class TreeMultimapNode extends AVLTreeNode {
     count;
@@ -21,20 +21,17 @@ export class TreeMultimapNode extends AVLTreeNode {
  * 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 class TreeMultimap extends AVLTree {
-    /**
-     * The constructor function for a TreeMultimap class in TypeScript, which extends another class and sets an option to
-     * merge duplicated values.
-     * @param {TreeMultimapOptions} [options] - An optional object that contains additional configuration options for the
-     * TreeMultimap.
-     */
     constructor(elements, options) {
         super([], options);
         if (elements)
-            this.init(elements);
+            this.addMany(elements);
     }
     _count = 0;
+    // TODO the _count is not accurate after nodes count modified
     get count() {
-        return this._count;
+        let sum = 0;
+        this.subTreeTraverse(node => sum += node.count);
+        return sum;
     }
     /**
      * The function creates a new BSTNode with the given key, value, and count.
@@ -54,131 +51,68 @@ export class TreeMultimap extends AVLTree {
             comparator: this.comparator, ...options
         });
     }
+    /**
+     * 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.
+     */
     /**
      * 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.
      *
-     * The `add` function adds a new node to the tree multimap, updating the count if the key already
-     * exists, and balances the tree if necessary.
-     * @param {BTNKey | N | null | undefined} keyOrNode - The `keyOrNode` parameter can be one of the
-     * following types:
-     * @param {V} [value] - The `value` parameter represents the value associated with the key that is
-     * being added to the tree. It is an optional parameter, so it can be omitted if not needed.
+     * The `add` function overrides the base class `add` function to add a new node to the tree multimap
+     * and update the count.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
      * @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 multimap. If not provided, the default value is 1.
-     * @returns a node (`N`) or `undefined`.
+     * times the key or node or entry should be added to the multimap. If not provided, the default value
+     * is 1.
+     * @returns either a node (`N`) or `undefined`.
      */
-    add(keyOrNode, value, count = 1) {
-        if (keyOrNode === null)
-            return undefined;
-        let inserted = undefined, newNode;
-        if (keyOrNode instanceof TreeMultimapNode) {
-            newNode = this.createNode(keyOrNode.key, keyOrNode.value, keyOrNode.count);
+    add(keyOrNodeOrEntry, count = 1) {
+        let newNode;
+        if (keyOrNodeOrEntry === undefined || keyOrNodeOrEntry === null) {
+            return;
         }
-        else if (keyOrNode === undefined) {
-            newNode = undefined;
+        else if (keyOrNodeOrEntry instanceof TreeMultimapNode) {
+            newNode = keyOrNodeOrEntry;
         }
-        else {
-            newNode = this.createNode(keyOrNode, value, count);
+        else if (this.isNodeKey(keyOrNodeOrEntry)) {
+            newNode = this.createNode(keyOrNodeOrEntry, undefined, count);
         }
-        if (!this.root) {
-            this._setRoot(newNode);
-            this._size = this.size + 1;
-            if (newNode)
-                this._count += newNode.count;
-            inserted = this.root;
+        else if (this.isEntry(keyOrNodeOrEntry)) {
+            const [key, value] = keyOrNodeOrEntry;
+            if (key === undefined || key === null) {
+                return;
+            }
+            else {
+                newNode = this.createNode(key, value, count);
+            }
         }
         else {
-            let cur = this.root;
-            let traversing = true;
-            while (traversing) {
-                if (cur) {
-                    if (newNode) {
-                        if (this._compare(cur.key, newNode.key) === CP.eq) {
-                            cur.value = newNode.value;
-                            cur.count += newNode.count;
-                            this._count += newNode.count;
-                            traversing = false;
-                            inserted = cur;
-                        }
-                        else if (this._compare(cur.key, newNode.key) === CP.gt) {
-                            // Traverse left of the node
-                            if (cur.left === undefined) {
-                                //Add to the left of the current node
-                                cur.left = newNode;
-                                this._size = this.size + 1;
-                                this._count += newNode.count;
-                                traversing = false;
-                                inserted = cur.left;
-                            }
-                            else {
-                                //Traverse the left of the current node
-                                if (cur.left)
-                                    cur = cur.left;
-                            }
-                        }
-                        else if (this._compare(cur.key, newNode.key) === CP.lt) {
-                            // Traverse right of the node
-                            if (cur.right === undefined) {
-                                //Add to the right of the current node
-                                cur.right = newNode;
-                                this._size = this.size + 1;
-                                this._count += newNode.count;
-                                traversing = false;
-                                inserted = cur.right;
-                            }
-                            else {
-                                //Traverse the left of the current node
-                                if (cur.right)
-                                    cur = cur.right;
-                            }
-                        }
-                    }
-                    else {
-                        // TODO may need to support undefined inserted
-                    }
-                }
-                else {
-                    traversing = false;
-                }
-            }
+            return;
+        }
+        const orgNodeCount = newNode?.count || 0;
+        const inserted = super.add(newNode);
+        if (inserted) {
+            this._count += orgNodeCount;
         }
-        if (inserted)
-            this._balancePath(inserted);
         return inserted;
     }
     /**
-     * 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.
+     * 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.
      */
     /**
-     * Time Complexity: O(k log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each.
+     * 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.
      *
-     * The function `addMany` takes an array of keys or nodes and adds them to the TreeMultimap,
-     * returning an array of the inserted nodes.
-     * @param {(BTNKey | N | undefined)[]} keysOrNodes - An array of keys or nodes. Each element can be
-     * of type BTNKey, N, or undefined.
-     * @param {V[]} [data] - The `data` parameter is an optional array of values that correspond to the
-     * keys or nodes being added. It is used to associate data with each key or node being added to the
-     * TreeMultimap. If provided, the length of the `data` array should be the same as the length of the
-     * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
+     * The function overrides the addMany method to add multiple keys, nodes, or entries to a data
+     * structure.
+     * @param keysOrNodesOrEntries - The parameter `keysOrNodesOrEntries` is an iterable that can contain
+     * either keys, nodes, or entries.
+     * @returns The method is returning an array of type `N | undefined`.
      */
-    addMany(keysOrNodes, data) {
-        const inserted = [];
-        for (let i = 0; i < keysOrNodes.length; i++) {
-            const keyOrNode = keysOrNodes[i];
-            if (keyOrNode instanceof TreeMultimapNode) {
-                inserted.push(this.add(keyOrNode.key, keyOrNode.value, keyOrNode.count));
-                continue;
-            }
-            if (keyOrNode === undefined) {
-                inserted.push(this.add(NaN, undefined, 0));
-                continue;
-            }
-            inserted.push(this.add(keyOrNode, data?.[i], 1));
-        }
-        return inserted;
+    addMany(keysOrNodesOrEntries) {
+        return super.addMany(keysOrNodesOrEntries);
     }
     /**
      * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
@@ -206,7 +140,7 @@ export class TreeMultimap extends AVLTree {
                     return;
                 const m = l + Math.floor((r - l) / 2);
                 const midNode = sorted[m];
-                this.add(midNode.key, midNode.value, midNode.count);
+                this.add([midNode.key, midNode.value], midNode.count);
                 buildBalanceBST(l, m - 1);
                 buildBalanceBST(m + 1, r);
             };
@@ -222,7 +156,7 @@ export class TreeMultimap extends AVLTree {
                     if (l <= r) {
                         const m = l + Math.floor((r - l) / 2);
                         const midNode = sorted[m];
-                        this.add(midNode.key, midNode.value, midNode.count);
+                        this.add([midNode.key, midNode.value], midNode.count);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
                     }
@@ -288,7 +222,7 @@ export class TreeMultimap extends AVLTree {
                 const leftSubTreeRightMost = curr.left ? this.getRightMost(curr.left) : undefined;
                 if (leftSubTreeRightMost) {
                     const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
-                    orgCurrent = this._swap(curr, leftSubTreeRightMost);
+                    orgCurrent = this._swapProperties(curr, leftSubTreeRightMost);
                     if (parentOfLeftSubTreeMax) {
                         if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost) {
                             parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
@@ -322,23 +256,6 @@ export class TreeMultimap extends AVLTree {
         super.clear();
         this._count = 0;
     }
-    /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete 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.
-     */
-    init(elements) {
-        if (elements) {
-            for (const entryOrKey of elements) {
-                if (Array.isArray(entryOrKey)) {
-                    const [key, value] = entryOrKey;
-                    this.add(key, value);
-                }
-                else {
-                    this.add(entryOrKey);
-                }
-            }
-        }
-    }
     /**
      * 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.
@@ -355,7 +272,7 @@ export class TreeMultimap extends AVLTree {
      * added, or `undefined` if no node was added.
      */
     _addTo(newNode, parent) {
-        parent = this.ensureNotKey(parent);
+        parent = this.ensureNode(parent);
         if (parent) {
             if (parent.left === undefined) {
                 parent.left = newNode;
@@ -382,7 +299,7 @@ export class TreeMultimap extends AVLTree {
         }
     }
     /**
-     * The `_swap` function swaps the key, value, count, and height properties between two nodes.
+     * The `_swapProperties` function swaps the key, value, count, and height properties between two nodes.
      * @param {BTNKey | N | undefined} srcNode - The `srcNode` parameter represents the source node from
      * which the values will be swapped. It can be of type `BTNKey`, `N`, or `undefined`.
      * @param {BTNKey | N | undefined} destNode - The `destNode` parameter represents the destination
@@ -390,9 +307,9 @@ export class TreeMultimap extends AVLTree {
      * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
      * if either `srcNode` or `destNode` is undefined.
      */
-    _swap(srcNode, destNode) {
-        srcNode = this.ensureNotKey(srcNode);
-        destNode = this.ensureNotKey(destNode);
+    _swapProperties(srcNode, destNode) {
+        srcNode = this.ensureNode(srcNode);
+        destNode = this.ensureNode(destNode);
         if (srcNode && destNode) {
             const { key, value, count, height } = destNode;
             const tempNode = this.createNode(key, value, count);
@@ -411,4 +328,8 @@ export class TreeMultimap extends AVLTree {
         }
         return undefined;
     }
+    _replaceNode(oldNode, newNode) {
+        newNode.count = oldNode.count + newNode.count;
+        return super._replaceNode(oldNode, newNode);
+    }
 }

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

@@ -47,13 +47,13 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * @param value
      */
     abstract createEdge(srcOrV1: VertexKey, destOrV2: VertexKey, weight?: number, value?: E): EO;
-    abstract deleteEdge(edge: EO): EO | null;
-    abstract getEdge(srcOrKey: VO | VertexKey, destOrKey: VO | VertexKey): EO | null;
+    abstract deleteEdge(edge: EO): EO | undefined;
+    abstract getEdge(srcOrKey: VO | VertexKey, destOrKey: VO | VertexKey): EO | undefined;
     abstract degreeOf(vertexOrKey: VO | VertexKey): number;
     abstract edgeSet(): EO[];
     abstract edgesOf(vertexOrKey: VO | VertexKey): EO[];
     abstract getNeighbors(vertexOrKey: VO | VertexKey): VO[];
-    abstract getEndsOfEdge(edge: EO): [VO, VO] | null;
+    abstract getEndsOfEdge(edge: EO): [VO, VO] | undefined;
     /**
      * Time Complexity: O(1) - Constant time for Map lookup.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
@@ -62,13 +62,13 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * Time Complexity: O(1) - Constant time for Map lookup.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
      *
-     * The function "getVertex" returns the vertex with the specified ID or null if it doesn't exist.
+     * The function "getVertex" returns the vertex with the specified ID or undefined if it doesn't exist.
      * @param {VertexKey} vertexKey - The `vertexKey` parameter is the identifier of the vertex that you want to retrieve from
      * the `_vertices` map.
      * @returns The method `getVertex` returns the vertex with the specified `vertexKey` if it exists in the `_vertices`
-     * map. If the vertex does not exist, it returns `null`.
+     * map. If the vertex does not exist, it returns `undefined`.
      */
-    getVertex(vertexKey: VertexKey): VO | null;
+    getVertex(vertexKey: VertexKey): VO | undefined;
     /**
      * Time Complexity: O(1) - Constant time for Map lookup.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
@@ -201,7 +201,7 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * vertices. If `isWeight` is `false` or not provided, it uses a breadth-first search (BFS) algorithm to calculate the
      * minimum number of
      */
-    getMinCostBetween(v1: VO | VertexKey, v2: VO | VertexKey, isWeight?: boolean): number | null;
+    getMinCostBetween(v1: VO | VertexKey, v2: VO | VertexKey, isWeight?: boolean): number | undefined;
     /**
      * Time Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm or DFS).
      * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm or DFS).
@@ -223,9 +223,9 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * followed by iterative computation of the shortest path. This approach may result in exponential time complexity,
      * so the default method is to use the Dijkstra algorithm to obtain the shortest weighted path.
      * @returns The function `getMinPathBetween` returns an array of vertices (`VO[]`) representing the minimum path between
-     * two vertices (`v1` and `v2`). If there is no path between the vertices, it returns `null`.
+     * two vertices (`v1` and `v2`). If there is no path between the vertices, it returns `undefined`.
      */
-    getMinPathBetween(v1: VO | VertexKey, v2: VO | VertexKey, isWeight?: boolean, isDFS?: boolean): VO[] | null;
+    getMinPathBetween(v1: VO | VertexKey, v2: VO | VertexKey, isWeight?: boolean, isDFS?: boolean): VO[] | undefined;
     /**
      *  Dijkstra algorithm time: O(VE) space: O(VO + EO)
      * /
@@ -242,9 +242,9 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * a graph without using a heap data structure.
      * @param {VO | VertexKey} src - The source vertex from which to start the Dijkstra's algorithm. It can be either a
      * vertex object or a vertex ID.
-     * @param {VO | VertexKey | null} [dest] - The `dest` parameter in the `dijkstraWithoutHeap` function is an optional
+     * @param {VO | VertexKey | undefined} [dest] - The `dest` parameter in the `dijkstraWithoutHeap` function is an optional
      * parameter that specifies the destination vertex for the Dijkstra algorithm. It can be either a vertex object or its
-     * identifier. If no destination is provided, the value is set to `null`.
+     * identifier. If no destination is provided, the value is set to `undefined`.
      * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
      * distance from the source vertex to the destination vertex should be calculated and returned in the result. If
      * `getMinDist` is set to `true`, the `minDist` property in the result will contain the minimum distance
@@ -253,7 +253,7 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * shortest paths from the source vertex to all other vertices in the graph. If `genPaths
      * @returns The function `dijkstraWithoutHeap` returns an object of type `DijkstraResult<VO>`.
      */
-    dijkstraWithoutHeap(src: VO | VertexKey, dest?: VO | VertexKey | null, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<VO>;
+    dijkstraWithoutHeap(src: VO | VertexKey, dest?: VO | VertexKey | undefined, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<VO>;
     /**
      *  Dijkstra algorithm time: O(logVE) space: O(VO + EO)
      *
@@ -276,7 +276,7 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * optional destination vertex, and optionally returns the minimum distance, the paths, and other information.
      * @param {VO | VertexKey} src - The `src` parameter represents the source vertex from which the Dijkstra algorithm will
      * start. It can be either a vertex object or a vertex ID.
-     * @param {VO | VertexKey | null} [dest] - The `dest` parameter is the destination vertex or vertex ID. It specifies the
+     * @param {VO | VertexKey | undefined} [dest] - The `dest` parameter is the destination vertex or vertex ID. It specifies the
      * vertex to which the shortest path is calculated from the source vertex. If no destination is provided, the algorithm
      * will calculate the shortest paths to all other vertices from the source vertex.
      * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
@@ -287,7 +287,7 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * shortest paths from the source vertex to all other vertices in the graph. If `genPaths
      * @returns The function `dijkstra` returns an object of type `DijkstraResult<VO>`.
      */
-    dijkstra(src: VO | VertexKey, dest?: VO | VertexKey | null, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<VO>;
+    dijkstra(src: VO | VertexKey, dest?: VO | VertexKey | undefined, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<VO>;
     /**
      * Time Complexity: O(V * E) - Quadratic time in the worst case (Bellman-Ford algorithm).
      * Space Complexity: O(V + E) - Depends on the implementation (Bellman-Ford algorithm).
@@ -353,12 +353,12 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * graph.
      * @returns The function `floydWarshall()` returns an object with two properties: `costs` and `predecessor`. The `costs`
      * property is a 2D array of numbers representing the shortest path costs between vertices in a graph. The
-     * `predecessor` property is a 2D array of vertices (or `null`) representing the predecessor vertices in the shortest
+     * `predecessor` property is a 2D array of vertices (or `undefined`) representing the predecessor vertices in the shortest
      * path between vertices in the
      */
     floydWarshall(): {
         costs: number[][];
-        predecessor: (VO | null)[][];
+        predecessor: (VO | undefined)[][];
     };
     /**
      * Time Complexity: O(V + E) - Linear time (Tarjan's algorithm).
@@ -445,6 +445,6 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
     getBridges(): EO[];
     protected abstract _addEdgeOnly(edge: EO): boolean;
     protected _addVertexOnly(newVertex: VO): boolean;
-    protected _getVertex(vertexOrKey: VertexKey | VO): VO | null;
+    protected _getVertex(vertexOrKey: VertexKey | VO): VO | undefined;
     protected _getVertexKey(vertexOrKey: VO | VertexKey): VertexKey;
 }

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

@@ -58,14 +58,14 @@ export class AbstractGraph {
      * Time Complexity: O(1) - Constant time for Map lookup.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
      *
-     * The function "getVertex" returns the vertex with the specified ID or null if it doesn't exist.
+     * The function "getVertex" returns the vertex with the specified ID or undefined if it doesn't exist.
      * @param {VertexKey} vertexKey - The `vertexKey` parameter is the identifier of the vertex that you want to retrieve from
      * the `_vertices` map.
      * @returns The method `getVertex` returns the vertex with the specified `vertexKey` if it exists in the `_vertices`
-     * map. If the vertex does not exist, it returns `null`.
+     * map. If the vertex does not exist, it returns `undefined`.
      */
     getVertex(vertexKey) {
-        return this._vertices.get(vertexKey) || null;
+        return this._vertices.get(vertexKey) || undefined;
     }
     /**
      * Time Complexity: O(1) - Constant time for Map lookup.
@@ -302,7 +302,7 @@ export class AbstractGraph {
             const vertex2 = this._getVertex(v2);
             const vertex1 = this._getVertex(v1);
             if (!(vertex1 && vertex2)) {
-                return null;
+                return undefined;
             }
             const visited = new Map();
             const queue = new Queue([vertex1]);
@@ -327,7 +327,7 @@ export class AbstractGraph {
                 }
                 cost++;
             }
-            return null;
+            return undefined;
         }
     }
     /**
@@ -351,7 +351,7 @@ export class AbstractGraph {
      * followed by iterative computation of the shortest path. This approach may result in exponential time complexity,
      * so the default method is to use the Dijkstra algorithm to obtain the shortest weighted path.
      * @returns The function `getMinPathBetween` returns an array of vertices (`VO[]`) representing the minimum path between
-     * two vertices (`v1` and `v2`). If there is no path between the vertices, it returns `null`.
+     * two vertices (`v1` and `v2`). If there is no path between the vertices, it returns `undefined`.
      */
     getMinPathBetween(v1, v2, isWeight, isDFS = false) {
         if (isWeight === undefined)
@@ -370,7 +370,7 @@ export class AbstractGraph {
                     }
                     index++;
                 }
-                return allPaths[minIndex] || null;
+                return allPaths[minIndex] || undefined;
             }
             else {
                 return this.dijkstra(v1, v2, true, true)?.minPath ?? [];
@@ -419,9 +419,9 @@ export class AbstractGraph {
      * a graph without using a heap data structure.
      * @param {VO | VertexKey} src - The source vertex from which to start the Dijkstra's algorithm. It can be either a
      * vertex object or a vertex ID.
-     * @param {VO | VertexKey | null} [dest] - The `dest` parameter in the `dijkstraWithoutHeap` function is an optional
+     * @param {VO | VertexKey | undefined} [dest] - The `dest` parameter in the `dijkstraWithoutHeap` function is an optional
      * parameter that specifies the destination vertex for the Dijkstra algorithm. It can be either a vertex object or its
-     * identifier. If no destination is provided, the value is set to `null`.
+     * identifier. If no destination is provided, the value is set to `undefined`.
      * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
      * distance from the source vertex to the destination vertex should be calculated and returned in the result. If
      * `getMinDist` is set to `true`, the `minDist` property in the result will contain the minimum distance
@@ -436,9 +436,9 @@ export class AbstractGraph {
         if (genPaths === undefined)
             genPaths = false;
         if (dest === undefined)
-            dest = null;
+            dest = undefined;
         let minDist = Infinity;
-        let minDest = null;
+        let minDest = undefined;
         let minPath = [];
         const paths = [];
         const vertices = this._vertices;
@@ -446,9 +446,9 @@ export class AbstractGraph {
         const seen = new Set();
         const preMap = new Map(); // predecessor
         const srcVertex = this._getVertex(src);
-        const destVertex = dest ? this._getVertex(dest) : null;
+        const destVertex = dest ? this._getVertex(dest) : undefined;
         if (!srcVertex) {
-            return null;
+            return undefined;
         }
         for (const vertex of vertices) {
             const vertexOrKey = vertex[1];
@@ -456,10 +456,10 @@ export class AbstractGraph {
                 distMap.set(vertexOrKey, Infinity);
         }
         distMap.set(srcVertex, 0);
-        preMap.set(srcVertex, null);
+        preMap.set(srcVertex, undefined);
         const getMinOfNoSeen = () => {
             let min = Infinity;
-            let minV = null;
+            let minV = undefined;
             for (const [key, value] of distMap) {
                 if (!seen.has(key)) {
                     if (value < min) {
@@ -507,7 +507,7 @@ export class AbstractGraph {
                         if (edge) {
                             const curFromMap = distMap.get(cur);
                             const neighborFromMap = distMap.get(neighbor);
-                            // TODO after no-non-null-assertion not ensure the logic
+                            // TODO after no-non-undefined-assertion not ensure the logic
                             if (curFromMap !== undefined && neighborFromMap !== undefined) {
                                 if (edge.weight + curFromMap < neighborFromMap) {
                                     distMap.set(neighbor, edge.weight + curFromMap);
@@ -554,7 +554,7 @@ export class AbstractGraph {
      * optional destination vertex, and optionally returns the minimum distance, the paths, and other information.
      * @param {VO | VertexKey} src - The `src` parameter represents the source vertex from which the Dijkstra algorithm will
      * start. It can be either a vertex object or a vertex ID.
-     * @param {VO | VertexKey | null} [dest] - The `dest` parameter is the destination vertex or vertex ID. It specifies the
+     * @param {VO | VertexKey | undefined} [dest] - The `dest` parameter is the destination vertex or vertex ID. It specifies the
      * vertex to which the shortest path is calculated from the source vertex. If no destination is provided, the algorithm
      * will calculate the shortest paths to all other vertices from the source vertex.
      * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
@@ -571,9 +571,9 @@ export class AbstractGraph {
         if (genPaths === undefined)
             genPaths = false;
         if (dest === undefined)
-            dest = null;
+            dest = undefined;
         let minDist = Infinity;
-        let minDest = null;
+        let minDest = undefined;
         let minPath = [];
         const paths = [];
         const vertices = this._vertices;
@@ -581,9 +581,9 @@ export class AbstractGraph {
         const seen = new Set();
         const preMap = new Map(); // predecessor
         const srcVertex = this._getVertex(src);
-        const destVertex = dest ? this._getVertex(dest) : null;
+        const destVertex = dest ? this._getVertex(dest) : undefined;
         if (!srcVertex)
-            return null;
+            return undefined;
         for (const vertex of vertices) {
             const vertexOrKey = vertex[1];
             if (vertexOrKey instanceof AbstractVertex)
@@ -592,11 +592,11 @@ export class AbstractGraph {
         const heap = new PriorityQueue([], { comparator: (a, b) => a.key - b.key });
         heap.add({ key: 0, value: srcVertex });
         distMap.set(srcVertex, 0);
-        preMap.set(srcVertex, null);
+        preMap.set(srcVertex, undefined);
         /**
          * The function `getPaths` retrieves all paths from vertices to a specified minimum vertex.
-         * @param {VO | null} minV - The parameter `minV` is of type `VO | null`. It represents the minimum vertex value or
-         * null.
+         * @param {VO | undefined} minV - The parameter `minV` is of type `VO | undefined`. It represents the minimum vertex value or
+         * undefined.
          */
         const getPaths = (minV) => {
             for (const vertex of vertices) {
@@ -732,7 +732,7 @@ export class AbstractGraph {
                 }
             }
         }
-        let minDest = null;
+        let minDest = undefined;
         if (getMin) {
             distMap.forEach((d, v) => {
                 if (v !== srcVertex) {
@@ -808,7 +808,7 @@ export class AbstractGraph {
      * graph.
      * @returns The function `floydWarshall()` returns an object with two properties: `costs` and `predecessor`. The `costs`
      * property is a 2D array of numbers representing the shortest path costs between vertices in a graph. The
-     * `predecessor` property is a 2D array of vertices (or `null`) representing the predecessor vertices in the shortest
+     * `predecessor` property is a 2D array of vertices (or `undefined`) representing the predecessor vertices in the shortest
      * path between vertices in the
      */
     floydWarshall() {
@@ -821,7 +821,7 @@ export class AbstractGraph {
             costs[i] = [];
             predecessor[i] = [];
             for (let j = 0; j < n; j++) {
-                predecessor[i][j] = null;
+                predecessor[i][j] = undefined;
             }
         }
         for (let i = 0; i < n; i++) {
@@ -913,7 +913,7 @@ export class AbstractGraph {
                     }
                     const childLow = lowMap.get(neighbor);
                     const curLow = lowMap.get(cur);
-                    // TODO after no-non-null-assertion not ensure the logic
+                    // TODO after no-non-undefined-assertion not ensure the logic
                     if (curLow !== undefined && childLow !== undefined) {
                         lowMap.set(cur, Math.min(curLow, childLow));
                     }
@@ -937,7 +937,7 @@ export class AbstractGraph {
                 }
             }
         };
-        dfs(root, null);
+        dfs(root, undefined);
         let SCCs = new Map();
         const getSCCs = () => {
             const SCCs = new Map();
@@ -1031,7 +1031,7 @@ export class AbstractGraph {
     }
     _getVertex(vertexOrKey) {
         const vertexKey = this._getVertexKey(vertexOrKey);
-        return this._vertices.get(vertexKey) || null;
+        return this._vertices.get(vertexKey) || undefined;
     }
     _getVertexKey(vertexOrKey) {
         return vertexOrKey instanceof AbstractVertex ? vertexOrKey.key : vertexOrKey;