data-structure-typed 1.47.7 → 1.47.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.47.7",
+  "version": "1.47.9",
   "description": "Data Structures of Javascript & TypeScript. Heap, Binary Tree, RedBlack Tree, Linked List, Deque, Trie, HashMap, Directed Graph, Undirected Graph, Binary Search Tree(BST), AVL Tree, Priority Queue, Graph, Queue, Tree Multiset, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue, Stack.",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",

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

@@ -11,16 +11,16 @@ import type { SegmentTreeNodeVal } from '../../types';
 export class SegmentTreeNode {
   start = 0;
   end = 0;
-  value: SegmentTreeNodeVal | null = null;
+  value: SegmentTreeNodeVal | undefined = undefined;
   sum = 0;
-  left: SegmentTreeNode | null = null;
-  right: SegmentTreeNode | null = null;
+  left: SegmentTreeNode | undefined = undefined;
+  right: SegmentTreeNode | undefined = undefined;
 
-  constructor(start: number, end: number, sum: number, value?: SegmentTreeNodeVal | null) {
+  constructor(start: number, end: number, sum: number, value?: SegmentTreeNodeVal | undefined) {
     this.start = start;
     this.end = end;
     this.sum = sum;
-    this.value = value || null;
+    this.value = value || undefined;
   }
 }
 
@@ -44,7 +44,7 @@ export class SegmentTree {
     if (values.length > 0) {
       this._root = this.build(start, end);
     } else {
-      this._root = null;
+      this._root = undefined;
       this._values = [];
     }
   }
@@ -67,9 +67,9 @@ export class SegmentTree {
     return this._end;
   }
 
-  protected _root: SegmentTreeNode | null;
+  protected _root: SegmentTreeNode | undefined;
 
-  get root(): SegmentTreeNode | null {
+  get root(): SegmentTreeNode | undefined {
     return this._root;
   }
 
@@ -109,7 +109,7 @@ export class SegmentTree {
    * @returns The function does not return anything.
    */
   updateNode(index: number, sum: number, value?: SegmentTreeNodeVal) {
-    const root = this.root || null;
+    const root = this.root || undefined;
     if (!root) {
       return;
     }
@@ -145,7 +145,7 @@ export class SegmentTree {
    * @returns The function `querySumByRange` returns a number.
    */
   querySumByRange(indexA: number, indexB: number): number {
-    const root = this.root || null;
+    const root = this.root || undefined;
     if (!root) {
       return 0;
     }

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

@@ -89,9 +89,9 @@ export abstract class AbstractGraph<
    */
   abstract createEdge(srcOrV1: VertexKey, destOrV2: VertexKey, weight?: number, value?: E): EO;
 
-  abstract deleteEdge(edge: EO): EO | null;
+  abstract deleteEdge(edge: EO): EO | undefined;
 
-  abstract getEdge(srcOrKey: VO | VertexKey, destOrKey: VO | VertexKey): EO | null;
+  abstract getEdge(srcOrKey: VO | VertexKey, destOrKey: VO | VertexKey): EO | undefined;
 
   abstract degreeOf(vertexOrKey: VO | VertexKey): number;
 
@@ -101,7 +101,7 @@ export abstract class AbstractGraph<
 
   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.
@@ -112,14 +112,14 @@ export abstract 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: VertexKey): VO | null {
-    return this._vertices.get(vertexKey) || null;
+  getVertex(vertexKey: VertexKey): VO | undefined {
+    return this._vertices.get(vertexKey) || undefined;
   }
 
   /**
@@ -365,7 +365,7 @@ export abstract class AbstractGraph<
    * 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 {
     if (isWeight === undefined) isWeight = false;
 
     if (isWeight) {
@@ -380,7 +380,7 @@ export abstract class AbstractGraph<
       const vertex2 = this._getVertex(v2);
       const vertex1 = this._getVertex(v1);
       if (!(vertex1 && vertex2)) {
-        return null;
+        return undefined;
       }
 
       const visited: Map<VO, boolean> = new Map();
@@ -406,7 +406,7 @@ export abstract class AbstractGraph<
         }
         cost++;
       }
-      return null;
+      return undefined;
     }
   }
 
@@ -432,9 +432,9 @@ export abstract 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: VO | VertexKey, v2: VO | VertexKey, isWeight?: boolean, isDFS = false): VO[] | null {
+  getMinPathBetween(v1: VO | VertexKey, v2: VO | VertexKey, isWeight?: boolean, isDFS = false): VO[] | undefined {
     if (isWeight === undefined) isWeight = false;
 
     if (isWeight) {
@@ -451,7 +451,7 @@ export abstract class AbstractGraph<
           }
           index++;
         }
-        return allPaths[minIndex] || null;
+        return allPaths[minIndex] || undefined;
       } else {
         return this.dijkstra(v1, v2, true, true)?.minPath ?? [];
       }
@@ -503,9 +503,9 @@ export abstract 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
@@ -516,29 +516,29 @@ export abstract class AbstractGraph<
    */
   dijkstraWithoutHeap(
     src: VO | VertexKey,
-    dest?: VO | VertexKey | null,
+    dest?: VO | VertexKey | undefined,
     getMinDist?: boolean,
     genPaths?: boolean
   ): DijkstraResult<VO> {
     if (getMinDist === undefined) getMinDist = false;
     if (genPaths === undefined) genPaths = false;
 
-    if (dest === undefined) dest = null;
+    if (dest === undefined) dest = undefined;
     let minDist = Infinity;
-    let minDest: VO | null = null;
+    let minDest: VO | undefined = undefined;
     let minPath: VO[] = [];
     const paths: VO[][] = [];
 
     const vertices = this._vertices;
     const distMap: Map<VO, number> = new Map();
     const seen: Set<VO> = new Set();
-    const preMap: Map<VO, VO | null> = new Map(); // predecessor
+    const preMap: Map<VO, VO | undefined> = 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) {
@@ -546,11 +546,11 @@ export abstract class AbstractGraph<
       if (vertexOrKey instanceof AbstractVertex) distMap.set(vertexOrKey, Infinity);
     }
     distMap.set(srcVertex, 0);
-    preMap.set(srcVertex, null);
+    preMap.set(srcVertex, undefined);
 
     const getMinOfNoSeen = () => {
       let min = Infinity;
-      let minV: VO | null = null;
+      let minV: VO | undefined = undefined;
       for (const [key, value] of distMap) {
         if (!seen.has(key)) {
           if (value < min) {
@@ -562,7 +562,7 @@ export abstract class AbstractGraph<
       return minV;
     };
 
-    const getPaths = (minV: VO | null) => {
+    const getPaths = (minV: VO | undefined) => {
       for (const vertex of vertices) {
         const vertexOrKey = vertex[1];
 
@@ -600,7 +600,7 @@ export abstract 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);
@@ -651,7 +651,7 @@ export abstract 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
@@ -664,27 +664,27 @@ export abstract class AbstractGraph<
    */
   dijkstra(
     src: VO | VertexKey,
-    dest?: VO | VertexKey | null,
+    dest?: VO | VertexKey | undefined,
     getMinDist?: boolean,
     genPaths?: boolean
   ): DijkstraResult<VO> {
     if (getMinDist === undefined) getMinDist = false;
     if (genPaths === undefined) genPaths = false;
 
-    if (dest === undefined) dest = null;
+    if (dest === undefined) dest = undefined;
     let minDist = Infinity;
-    let minDest: VO | null = null;
+    let minDest: VO | undefined = undefined;
     let minPath: VO[] = [];
     const paths: VO[][] = [];
     const vertices = this._vertices;
     const distMap: Map<VO, number> = new Map();
     const seen: Set<VO> = new Set();
-    const preMap: Map<VO, VO | null> = new Map(); // predecessor
+    const preMap: Map<VO, VO | undefined> = 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;
+    if (!srcVertex) return undefined;
 
     for (const vertex of vertices) {
       const vertexOrKey = vertex[1];
@@ -695,14 +695,14 @@ export abstract class AbstractGraph<
     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: VO | null) => {
+    const getPaths = (minV: VO | undefined) => {
       for (const vertex of vertices) {
         const vertexOrKey = vertex[1];
         if (vertexOrKey instanceof AbstractVertex) {
@@ -841,7 +841,7 @@ export abstract class AbstractGraph<
       }
     }
 
-    let minDest: VO | null = null;
+    let minDest: VO | undefined = undefined;
     if (getMin) {
       distMap.forEach((d, v) => {
         if (v !== srcVertex) {
@@ -920,22 +920,22 @@ export abstract 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(): { costs: number[][]; predecessor: (VO | null)[][] } {
+  floydWarshall(): { costs: number[][]; predecessor: (VO | undefined)[][] } {
     const idAndVertices = [...this._vertices];
     const n = idAndVertices.length;
 
     const costs: number[][] = [];
-    const predecessor: (VO | null)[][] = [];
+    const predecessor: (VO | undefined)[][] = [];
     // successors
 
     for (let i = 0; i < n; i++) {
       costs[i] = [];
       predecessor[i] = [];
       for (let j = 0; j < n; j++) {
-        predecessor[i][j] = null;
+        predecessor[i][j] = undefined;
       }
     }
 
@@ -1021,7 +1021,7 @@ export abstract class AbstractGraph<
     const cutVertexes: VO[] = [];
     const bridges: EO[] = [];
     let dfn = 0;
-    const dfs = (cur: VO, parent: VO | null) => {
+    const dfs = (cur: VO, parent: VO | undefined) => {
       dfn++;
       dfnMap.set(cur, dfn);
       lowMap.set(cur, dfn);
@@ -1036,7 +1036,7 @@ export abstract 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));
           }
@@ -1062,7 +1062,7 @@ export abstract class AbstractGraph<
       }
     };
 
-    dfs(root, null);
+    dfs(root, undefined);
 
     let SCCs: Map<number, VO[]> = new Map();
 
@@ -1159,6 +1159,52 @@ export abstract class AbstractGraph<
     return this.tarjan(false, true, false, false).bridges;
   }
 
+  * [Symbol.iterator](): Iterator<[VertexKey, V | undefined]> {
+    for (const vertex of this._vertices.values()) {
+      yield [vertex.key, vertex.value];
+    }
+  }
+
+  forEach(callback: (entry: [VertexKey, V | undefined], index: number, map: Map<VertexKey, VO>) => void): void {
+    let index = 0;
+    for (const vertex of this) {
+      callback(vertex, index, this._vertices);
+      index++;
+    }
+  }
+
+  filter(predicate: (entry: [VertexKey, V | undefined], index: number, map: Map<VertexKey, VO>) => boolean): [VertexKey, V | undefined][] {
+    const filtered: [VertexKey, V | undefined][] = [];
+    let index = 0;
+    for (const entry of this) {
+      if (predicate(entry, index, this._vertices)) {
+        filtered.push(entry);
+      }
+      index++;
+    }
+    return filtered;
+  }
+
+  map<T>(callback: (entry: [VertexKey, V | undefined], index: number, map: Map<VertexKey, VO>) => T): T[] {
+    const mapped: T[] = [];
+    let index = 0;
+    for (const entry of this) {
+      mapped.push(callback(entry, index, this._vertices));
+      index++;
+    }
+    return mapped;
+  }
+
+  reduce<T>(callback: (accumulator: T, entry: [VertexKey, V | undefined], index: number, map: Map<VertexKey, VO>) => T, initialValue: T): T {
+    let accumulator: T = initialValue;
+    let index = 0;
+    for (const entry of this) {
+      accumulator = callback(accumulator, entry, index, this._vertices);
+      index++;
+    }
+    return accumulator;
+  }
+
   protected abstract _addEdgeOnly(edge: EO): boolean;
 
   protected _addVertexOnly(newVertex: VO): boolean {
@@ -1170,9 +1216,9 @@ export abstract class AbstractGraph<
     return true;
   }
 
-  protected _getVertex(vertexOrKey: VertexKey | VO): VO | null {
+  protected _getVertex(vertexOrKey: VertexKey | VO): VO | undefined {
     const vertexKey = this._getVertexKey(vertexOrKey);
-    return this._vertices.get(vertexKey) || null;
+    return this._vertices.get(vertexKey) || undefined;
   }
 
   protected _getVertexKey(vertexOrKey: VO | VertexKey): VertexKey {

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

@@ -87,7 +87,7 @@ export class DirectedGraph<
    * @returns a new instance of a DirectedVertex object, casted as type VO.
    */
   createVertex(key: VertexKey, value?: V): VO {
-    return new DirectedVertex(key, value ?? key) as VO;
+    return new DirectedVertex(key, value) as VO;
   }
 
   /**
@@ -119,18 +119,18 @@ export class DirectedGraph<
    * Space Complexity: O(1)
    *
    * The `getEdge` function retrieves an edge between two vertices based on their source and destination IDs.
-   * @param {VO | VertexKey | null} srcOrKey - The source vertex or its ID. It can be either a vertex object or a vertex ID.
-   * @param {VO | VertexKey | null} destOrKey - The `destOrKey` parameter in the `getEdge` function represents the
-   * destination vertex of the edge. It can be either a vertex object (`VO`), a vertex ID (`VertexKey`), or `null` if the
+   * @param {VO | VertexKey | undefined} srcOrKey - The source vertex or its ID. It can be either a vertex object or a vertex ID.
+   * @param {VO | VertexKey | undefined} destOrKey - The `destOrKey` parameter in the `getEdge` function represents the
+   * destination vertex of the edge. It can be either a vertex object (`VO`), a vertex ID (`VertexKey`), or `undefined` if the
    * destination is not specified.
-   * @returns the first edge found between the source and destination vertices, or null if no such edge is found.
+   * @returns the first edge found between the source and destination vertices, or undefined if no such edge is found.
    */
-  getEdge(srcOrKey: VO | VertexKey | null, destOrKey: VO | VertexKey | null): EO | null {
+  getEdge(srcOrKey: VO | VertexKey | undefined, destOrKey: VO | VertexKey | undefined): EO | undefined {
     let edges: EO[] = [];
 
-    if (srcOrKey !== null && destOrKey !== null) {
-      const src: VO | null = this._getVertex(srcOrKey);
-      const dest: VO | null = this._getVertex(destOrKey);
+    if (srcOrKey !== undefined && destOrKey !== undefined) {
+      const src: VO | undefined = this._getVertex(srcOrKey);
+      const dest: VO | undefined = this._getVertex(destOrKey);
 
       if (src && dest) {
         const srcOutEdges = this._outEdgeMap.get(src);
@@ -140,7 +140,7 @@ export class DirectedGraph<
       }
     }
 
-    return edges[0] || null;
+    return edges[0] || undefined;
   }
 
   /**
@@ -155,14 +155,14 @@ export class DirectedGraph<
    * The function removes an edge between two vertices in a graph and returns the removed edge.
    * @param {VO | VertexKey} srcOrKey - The source vertex or its ID.
    * @param {VO | VertexKey} destOrKey - The `destOrKey` parameter represents the destination vertex or its ID.
-   * @returns the removed edge (EO) if it exists, or null if either the source or destination vertex does not exist.
+   * @returns the removed edge (EO) if it exists, or undefined if either the source or destination vertex does not exist.
    */
-  deleteEdgeSrcToDest(srcOrKey: VO | VertexKey, destOrKey: VO | VertexKey): EO | null {
-    const src: VO | null = this._getVertex(srcOrKey);
-    const dest: VO | null = this._getVertex(destOrKey);
-    let removed: EO | null = null;
+  deleteEdgeSrcToDest(srcOrKey: VO | VertexKey, destOrKey: VO | VertexKey): EO | undefined {
+    const src: VO | undefined = this._getVertex(srcOrKey);
+    const dest: VO | undefined = this._getVertex(destOrKey);
+    let removed: EO | undefined = undefined;
     if (!src || !dest) {
-      return null;
+      return undefined;
     }
 
     const srcOutEdges = this._outEdgeMap.get(src);
@@ -172,7 +172,7 @@ export class DirectedGraph<
 
     const destInEdges = this._inEdgeMap.get(dest);
     if (destInEdges) {
-      removed = arrayRemove<EO>(destInEdges, (edge: EO) => edge.src === src.key)[0] || null;
+      removed = arrayRemove<EO>(destInEdges, (edge: EO) => edge.src === src.key)[0] || undefined;
     }
     return removed;
   }
@@ -186,13 +186,13 @@ export class DirectedGraph<
    * Time Complexity: O(|E|) where |E| is the number of edges
    * Space Complexity: O(1)
    *
-   * The function removes an edge from a graph and returns the removed edge, or null if the edge was not found.
+   * The function removes an edge from a graph and returns the removed edge, or undefined if the edge was not found.
    * @param {EO} edge - The `edge` parameter is an object that represents an edge in a graph. It has two properties: `src`
    * and `dest`, which represent the source and destination vertices of the edge, respectively.
-   * @returns The method `deleteEdge` returns the removed edge (`EO`) if it exists, or `null` if the edge does not exist.
+   * @returns The method `deleteEdge` returns the removed edge (`EO`) if it exists, or `undefined` if the edge does not exist.
    */
-  deleteEdge(edge: EO): EO | null {
-    let removed: EO | null = null;
+  deleteEdge(edge: EO): EO | undefined {
+    let removed: EO | undefined = undefined;
     const src = this._getVertex(edge.src);
     const dest = this._getVertex(edge.dest);
     if (src && dest) {
@@ -361,11 +361,11 @@ export class DirectedGraph<
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
-   * The function "getEdgeSrc" returns the source vertex of an edge, or null if the edge does not exist.
+   * The function "getEdgeSrc" returns the source vertex of an edge, or undefined if the edge does not exist.
    * @param {EO} e - The parameter "e" is of type EO, which represents an edge in a graph.
-   * @returns either a vertex object (VO) or null.
+   * @returns either a vertex object (VO) or undefined.
    */
-  getEdgeSrc(e: EO): VO | null {
+  getEdgeSrc(e: EO): VO | undefined {
     return this._getVertex(e.src);
   }
 
@@ -380,9 +380,9 @@ export class DirectedGraph<
    *
    * The function "getEdgeDest" returns the destination vertex of an edge.
    * @param {EO} e - The parameter "e" is of type "EO", which represents an edge in a graph.
-   * @returns either a vertex object of type VO or null.
+   * @returns either a vertex object of type VO or undefined.
    */
-  getEdgeDest(e: EO): VO | null {
+  getEdgeDest(e: EO): VO | undefined {
     return this._getVertex(e.dest);
   }
 
@@ -396,12 +396,12 @@ export class DirectedGraph<
    * Space Complexity: O(1)
    *
    * The function `getDestinations` returns an array of destination vertices connected to a given vertex.
-   * @param {VO | VertexKey | null} vertex - The `vertex` parameter represents the starting vertex from which we want to
-   * find the destinations. It can be either a `VO` object, a `VertexKey` value, or `null`.
+   * @param {VO | VertexKey | undefined} vertex - The `vertex` parameter represents the starting vertex from which we want to
+   * find the destinations. It can be either a `VO` object, a `VertexKey` value, or `undefined`.
    * @returns an array of vertices (VO[]).
    */
-  getDestinations(vertex: VO | VertexKey | null): VO[] {
-    if (vertex === null) {
+  getDestinations(vertex: VO | VertexKey | undefined): VO[] {
+    if (vertex === undefined) {
       return [];
     }
     const destinations: VO[] = [];
@@ -425,13 +425,13 @@ export class DirectedGraph<
    * Space Complexity: O(|V|)
    *
    * The `topologicalSort` function performs a topological sort on a graph and returns an array of vertices or vertex IDs
-   * in the sorted order, or null if the graph contains a cycle.
+   * in the sorted order, or undefined if the graph contains a cycle.
    * @param {'vertex' | 'key'} [propertyName] - The `propertyName` parameter is an optional parameter that specifies the
    * property to use for sorting the vertices. It can have two possible values: 'vertex' or 'key'. If 'vertex' is
    * specified, the vertices themselves will be used for sorting. If 'key' is specified, the ids of
-   * @returns an array of vertices or vertex IDs in topological order. If there is a cycle in the graph, it returns null.
+   * @returns an array of vertices or vertex IDs in topological order. If there is a cycle in the graph, it returns undefined.
    */
-  topologicalSort(propertyName?: 'vertex' | 'key'): Array<VO | VertexKey> | null {
+  topologicalSort(propertyName?: 'vertex' | 'key'): Array<VO | VertexKey> | undefined {
     propertyName = propertyName ?? 'key';
     // When judging whether there is a cycle in the undirected graph, all nodes with degree of **<= 1** are enqueued
     // When judging whether there is a cycle in the directed graph, all nodes with **in degree = 0** are enqueued
@@ -463,7 +463,7 @@ export class DirectedGraph<
       }
     }
 
-    if (hasCycle) return null;
+    if (hasCycle) return undefined;
 
     if (propertyName === 'key') sorted = sorted.map(vertex => (vertex instanceof DirectedVertex ? vertex.key : vertex));
     return sorted.reverse();
@@ -510,7 +510,7 @@ export class DirectedGraph<
       const outEdges = this.outgoingEdgesOf(vertex);
       for (const outEdge of outEdges) {
         const neighbor = this._getVertex(outEdge.dest);
-        // TODO after no-non-null-assertion not ensure the logic
+        // TODO after no-non-undefined-assertion not ensure the logic
         if (neighbor) {
           neighbors.push(neighbor);
         }
@@ -529,21 +529,21 @@ export class DirectedGraph<
    * Space Complexity: O(1)
    *
    * The function "getEndsOfEdge" returns the source and destination vertices of an edge if it exists in the graph,
-   * otherwise it returns null.
+   * otherwise it returns undefined.
    * @param {EO} edge - The parameter `edge` is of type `EO`, which represents an edge in a graph.
    * @returns The function `getEndsOfEdge` returns an array containing two vertices `[VO, VO]` if the edge exists in the
-   * graph. If the edge does not exist, it returns `null`.
+   * graph. If the edge does not exist, it returns `undefined`.
    */
-  getEndsOfEdge(edge: EO): [VO, VO] | null {
+  getEndsOfEdge(edge: EO): [VO, VO] | undefined {
     if (!this.hasEdge(edge.src, edge.dest)) {
-      return null;
+      return undefined;
     }
     const v1 = this._getVertex(edge.src);
     const v2 = this._getVertex(edge.dest);
     if (v1 && v2) {
       return [v1, v2];
     } else {
-      return null;
+      return undefined;
     }
   }
 
@@ -570,7 +570,7 @@ export class DirectedGraph<
     const srcVertex = this._getVertex(edge.src);
     const destVertex = this._getVertex(edge.dest);
 
-    // TODO after no-non-null-assertion not ensure the logic
+    // TODO after no-non-undefined-assertion not ensure the logic
     if (srcVertex && destVertex) {
       const srcOutEdges = this._outEdgeMap.get(srcVertex);
       if (srcOutEdges) {