linked-list-typed 1.47.7 → 1.47.9

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

@@ -16,8 +16,8 @@ class LinkedListQueue extends linked_list_1.SinglyLinkedList {
         this.push(value);
     }
     /**
-     * The `dequeue` function removes and returns the first element from a queue, or returns null if the queue is empty.
-     * @returns The method is returning the element at the front of the queue, or null if the queue is empty.
+     * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
+     * @returns The method is returning the element at the front of the queue, or undefined if the queue is empty.
      */
     dequeue() {
         return this.shift();
@@ -100,7 +100,7 @@ class Queue {
      *
      * The `shift` function removes and returns the first element in the queue, and adjusts the internal data structure if
      * necessary to optimize performance.
-     * @returns The function `shift()` returns either the first element in the queue or `null` if the queue is empty.
+     * @returns The function `shift()` returns either the first element in the queue or `undefined` if the queue is empty.
      */
     shift() {
         if (this.size === 0)
@@ -123,9 +123,9 @@ class Queue {
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      *
-     * The `getFirst` function returns the first element of the array `_nodes` if it exists, otherwise it returns `null`.
+     * The `getFirst` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
      * @returns The `getFirst()` method returns the first element of the data structure, represented by the `_nodes` array at
-     * the `_offset` index. If the data structure is empty (size is 0), it returns `null`.
+     * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
      */
     getFirst() {
         return this.size > 0 ? this.nodes[this.offset] : undefined;
@@ -138,9 +138,9 @@ class Queue {
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      *
-     * The `peek` function returns the first element of the array `_nodes` if it exists, otherwise it returns `null`.
+     * The `peek` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
      * @returns The `peek()` method returns the first element of the data structure, represented by the `_nodes` array at
-     * the `_offset` index. If the data structure is empty (size is 0), it returns `null`.
+     * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
      */
     peek() {
         return this.getFirst();
@@ -153,9 +153,9 @@ class Queue {
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      *
-     * The `getLast` function returns the last element in an array-like data structure, or null if the structure is empty.
+     * The `getLast` function returns the last element in an array-like data structure, or undefined if the structure is empty.
      * @returns The method `getLast()` returns the last element of the `_nodes` array if the array is not empty. If the
-     * array is empty, it returns `null`.
+     * array is empty, it returns `undefined`.
      */
     getLast() {
         return this.size > 0 ? this.nodes[this.nodes.length - 1] : undefined;
@@ -168,9 +168,9 @@ class Queue {
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      *
-     * The `peekLast` function returns the last element in an array-like data structure, or null if the structure is empty.
+     * The `peekLast` function returns the last element in an array-like data structure, or undefined if the structure is empty.
      * @returns The method `peekLast()` returns the last element of the `_nodes` array if the array is not empty. If the
-     * array is empty, it returns `null`.
+     * array is empty, it returns `undefined`.
      */
     peekLast() {
         return this.getLast();
@@ -197,8 +197,8 @@ class Queue {
      * Time Complexity: O(n) - same as shift().
      * Space Complexity: O(1) - same as shift().
      *
-     * The `dequeue` function removes and returns the first element from a queue, or returns null if the queue is empty.
-     * @returns The method is returning a value of type E or null.
+     * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
+     * @returns The method is returning a value of type E or undefined.
      */
     dequeue() {
         return this.shift();

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

@@ -45,10 +45,10 @@ export declare class Stack<E = any> {
      * Time Complexity: O(1), as it only involves accessing the last element of the array.
      * Space Complexity: O(1), as it does not use any additional space.
      *
-     * The `peek` function returns the last element of an array, or null if the array is empty.
-     * @returns The `peek()` function returns the last element of the `_elements` array, or `null` if the array is empty.
+     * The `peek` function returns the last element of an array, or undefined if the array is empty.
+     * @returns The `peek()` function returns the last element of the `_elements` array, or `undefined` if the array is empty.
      */
-    peek(): E | null;
+    peek(): E | undefined;
     /**
      * Time Complexity: O(1), as it only involves accessing the last element of the array.
      * Space Complexity: O(1), as it does not use any additional space.
@@ -70,11 +70,11 @@ export declare class Stack<E = any> {
      * Time Complexity: O(1), as it only involves accessing the last element of the array.
      * Space Complexity: O(1), as it does not use any additional space.
      *
-     * The `pop` function removes and returns the last element from an array, or returns null if the array is empty.
+     * The `pop` function removes and returns the last element from an array, or returns undefined if the array is empty.
      * @returns The `pop()` method is returning the last element of the array `_elements` if the array is not empty. If the
-     * array is empty, it returns `null`.
+     * array is empty, it returns `undefined`.
      */
-    pop(): E | null;
+    pop(): E | undefined;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

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

@@ -62,12 +62,12 @@ class Stack {
      * Time Complexity: O(1), as it only involves accessing the last element of the array.
      * Space Complexity: O(1), as it does not use any additional space.
      *
-     * The `peek` function returns the last element of an array, or null if the array is empty.
-     * @returns The `peek()` function returns the last element of the `_elements` array, or `null` if the array is empty.
+     * The `peek` function returns the last element of an array, or undefined if the array is empty.
+     * @returns The `peek()` function returns the last element of the `_elements` array, or `undefined` if the array is empty.
      */
     peek() {
         if (this.isEmpty())
-            return null;
+            return undefined;
         return this.elements[this.elements.length - 1];
     }
     /**
@@ -94,14 +94,14 @@ class Stack {
      * Time Complexity: O(1), as it only involves accessing the last element of the array.
      * Space Complexity: O(1), as it does not use any additional space.
      *
-     * The `pop` function removes and returns the last element from an array, or returns null if the array is empty.
+     * The `pop` function removes and returns the last element from an array, or returns undefined if the array is empty.
      * @returns The `pop()` method is returning the last element of the array `_elements` if the array is not empty. If the
-     * array is empty, it returns `null`.
+     * array is empty, it returns `undefined`.
      */
     pop() {
         if (this.isEmpty())
-            return null;
-        return this.elements.pop() || null;
+            return undefined;
+        return this.elements.pop() || undefined;
     }
     /**
      * Time Complexity: O(n)

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

@@ -2,9 +2,9 @@ export type VertexKey = string | number;
 export type DijkstraResult<V> = {
     distMap: Map<V, number>;
     distPaths?: Map<V, V[]>;
-    preMap: Map<V, V | null>;
+    preMap: Map<V, V | undefined>;
     seen: Set<V>;
     paths: V[][];
     minDist: number;
     minPath: V[];
-} | null;
+} | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linked-list-typed",
-  "version": "1.47.7",
+  "version": "1.47.9",
   "description": "Linked List, Doubly Linked List, Singly Linked List. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -66,6 +66,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.47.7"
+    "data-structure-typed": "^1.47.9"
   }
 }

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 {