priority-queue-typed 1.47.6 → 1.47.8

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

@@ -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) {

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

@@ -100,26 +100,26 @@ export class UndirectedGraph<
    * Time Complexity: O(|E|), where |E| is the number of edges incident to the given vertex.
    * Space Complexity: O(1)
    *
-   * The function `getEdge` returns the first edge that connects two vertices, or null if no such edge exists.
-   * @param {VO | VertexKey | null} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `VO` (vertex
-   * object), `null`, or `VertexKey` (a string or number representing the ID of a vertex).
-   * @param {VO | VertexKey | null} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `VO` (vertex
-   * object), `null`, or `VertexKey` (vertex ID).
-   * @returns an edge (EO) or null.
+   * The function `getEdge` returns the first edge that connects two vertices, or undefined if no such edge exists.
+   * @param {VO | VertexKey | undefined} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `VO` (vertex
+   * object), `undefined`, or `VertexKey` (a string or number representing the ID of a vertex).
+   * @param {VO | VertexKey | undefined} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `VO` (vertex
+   * object), `undefined`, or `VertexKey` (vertex ID).
+   * @returns an edge (EO) or undefined.
    */
-  getEdge(v1: VO | VertexKey | null, v2: VO | VertexKey | null): EO | null {
+  getEdge(v1: VO | VertexKey | undefined, v2: VO | VertexKey | undefined): EO | undefined {
     let edges: EO[] | undefined = [];
 
-    if (v1 !== null && v2 !== null) {
-      const vertex1: VO | null = this._getVertex(v1);
-      const vertex2: VO | null = this._getVertex(v2);
+    if (v1 !== undefined && v2 !== undefined) {
+      const vertex1: VO | undefined = this._getVertex(v1);
+      const vertex2: VO | undefined = this._getVertex(v2);
 
       if (vertex1 && vertex2) {
         edges = this._edges.get(vertex1)?.filter(e => e.vertices.includes(vertex2.key));
       }
     }
 
-    return edges ? edges[0] || null : null;
+    return edges ? edges[0] || undefined : undefined;
   }
 
   /**
@@ -135,20 +135,20 @@ export class UndirectedGraph<
    * @param {VO | VertexKey} v1 - The parameter `v1` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
    * @param {VO | VertexKey} v2 - VO | VertexKey - This parameter can be either a vertex object (VO) or a vertex ID
    * (VertexKey). It represents the second vertex of the edge that needs to be removed.
-   * @returns the removed edge (EO) if it exists, or null if either of the vertices (VO) does not exist.
+   * @returns the removed edge (EO) if it exists, or undefined if either of the vertices (VO) does not exist.
    */
-  deleteEdgeBetween(v1: VO | VertexKey, v2: VO | VertexKey): EO | null {
-    const vertex1: VO | null = this._getVertex(v1);
-    const vertex2: VO | null = this._getVertex(v2);
+  deleteEdgeBetween(v1: VO | VertexKey, v2: VO | VertexKey): EO | undefined {
+    const vertex1: VO | undefined = this._getVertex(v1);
+    const vertex2: VO | undefined = this._getVertex(v2);
 
     if (!vertex1 || !vertex2) {
-      return null;
+      return undefined;
     }
 
     const v1Edges = this._edges.get(vertex1);
-    let removed: EO | null = null;
+    let removed: EO | undefined = undefined;
     if (v1Edges) {
-      removed = arrayRemove<EO>(v1Edges, (e: EO) => e.vertices.includes(vertex2.key))[0] || null;
+      removed = arrayRemove<EO>(v1Edges, (e: EO) => e.vertices.includes(vertex2.key))[0] || undefined;
     }
     const v2Edges = this._edges.get(vertex2);
     if (v2Edges) {
@@ -168,9 +168,9 @@ export class UndirectedGraph<
    *
    * The deleteEdge function removes an edge between two vertices in a graph.
    * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
-   * @returns The method is returning either the removed edge (of type EO) or null if the edge was not found.
+   * @returns The method is returning either the removed edge (of type EO) or undefined if the edge was not found.
    */
-  deleteEdge(edge: EO): EO | null {
+  deleteEdge(edge: EO): EO | undefined {
     return this.deleteEdgeBetween(edge.vertices[0], edge.vertices[1]);
   }
 
@@ -282,21 +282,21 @@ export class UndirectedGraph<
    * Space Complexity: O(1)
    *
    * The function "getEndsOfEdge" returns the vertices at the ends of an edge if the edge exists in the graph, otherwise
-   * it returns null.
+   * 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.vertices[0], edge.vertices[1])) {
-      return null;
+      return undefined;
     }
     const v1 = this._getVertex(edge.vertices[0]);
     const v2 = this._getVertex(edge.vertices[1]);
     if (v1 && v2) {
       return [v1, v2];
     } else {
-      return null;
+      return undefined;
     }
   }
 
@@ -316,7 +316,7 @@ export class UndirectedGraph<
   protected _addEdgeOnly(edge: EO): boolean {
     for (const end of edge.vertices) {
       const endVertex = this._getVertex(end);
-      if (endVertex === null) return false;
+      if (endVertex === undefined) return false;
       if (endVertex) {
         const edges = this._edges.get(endVertex);
         if (edges) {

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

@@ -19,20 +19,16 @@ export class HashMap<K = any, V = any> {
   protected _hashFn: (key: K) => string;
   protected _objHashFn: (key: K) => object;
 
-  /**
-   * The constructor initializes a HashMapLinkedNode with an optional iterable of key-value pairs.
-   * @param options - The `options` parameter is an object that contains the `elements` property. The
-   * `elements` property is an iterable that contains key-value pairs represented as arrays `[K, V]`.
-   */
-  constructor(options: HashMapOptions<K, V> = {
-    elements: [],
+
+  constructor(elements?: Iterable<[K, V]>, options: HashMapOptions<K> = {
+
     hashFn: (key: K) => String(key),
     objHashFn: (key: K) => (<object>key)
   }) {
     this._sentinel = <HashMapLinkedNode<K, V>>{};
     this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
 
-    const { elements, hashFn, objHashFn } = options;
+    const { hashFn, objHashFn } = options;
     this._hashFn = hashFn;
     this._objHashFn = objHashFn;
     if (elements) {
@@ -379,6 +375,10 @@ export class HashMap<K = any, V = any> {
     }
   }
 
+  print() {
+    console.log([...this]);
+  }
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)

package/src/data-structures/linked-list/doubly-linked-list.ts

@@ -7,8 +7,8 @@
  */
 export class DoublyLinkedListNode<E = any> {
   value: E;
-  next: DoublyLinkedListNode<E> | null;
-  prev: DoublyLinkedListNode<E> | null;
+  next: DoublyLinkedListNode<E> | undefined;
+  prev: DoublyLinkedListNode<E> | undefined;
 
   /**
    * The constructor function initializes the value, next, and previous properties of an object.
@@ -17,8 +17,8 @@ export class DoublyLinkedListNode<E = any> {
    */
   constructor(value: E) {
     this.value = value;
-    this.next = null;
-    this.prev = null;
+    this.next = undefined;
+    this.prev = undefined;
   }
 }
 
@@ -27,8 +27,8 @@ export class DoublyLinkedList<E = any> {
    * The constructor initializes the linked list with an empty head, tail, and length.
    */
   constructor(elements?: Iterable<E>) {
-    this._head = null;
-    this._tail = null;
+    this._head = undefined;
+    this._tail = undefined;
     this._length = 0;
     if (elements) {
       for (const el of elements) {
@@ -37,15 +37,15 @@ export class DoublyLinkedList<E = any> {
     }
   }
 
-  protected _head: DoublyLinkedListNode<E> | null;
+  protected _head: DoublyLinkedListNode<E> | undefined;
 
-  get head(): DoublyLinkedListNode<E> | null {
+  get head(): DoublyLinkedListNode<E> | undefined {
     return this._head;
   }
 
-  protected _tail: DoublyLinkedListNode<E> | null;
+  protected _tail: DoublyLinkedListNode<E> | undefined;
 
-  get tail(): DoublyLinkedListNode<E> | null {
+  get tail(): DoublyLinkedListNode<E> | undefined {
     return this._tail;
   }
 
@@ -133,17 +133,17 @@ export class DoublyLinkedList<E = any> {
    *
    * The `pop()` function removes and returns the value of the last node in a doubly linked list.
    * @returns The method is returning the value of the removed node (removedNode.value) if the list is not empty. If the
-   * list is empty, it returns null.
+   * list is empty, it returns undefined.
    */
   pop(): E | undefined {
     if (!this.tail) return undefined;
     const removedNode = this.tail;
     if (this.head === this.tail) {
-      this._head = null;
-      this._tail = null;
+      this._head = undefined;
+      this._tail = undefined;
     } else {
       this._tail = removedNode.prev;
-      this.tail!.next = null;
+      this.tail!.next = undefined;
     }
     this._length--;
     return removedNode.value;
@@ -160,7 +160,7 @@ export class DoublyLinkedList<E = any> {
    *
    * The `popLast()` function removes and returns the value of the last node in a doubly linked list.
    * @returns The method is returning the value of the removed node (removedNode.value) if the list is not empty. If the
-   * list is empty, it returns null.
+   * list is empty, it returns undefined.
    */
   popLast(): E | undefined {
     return this.pop();
@@ -183,11 +183,11 @@ export class DoublyLinkedList<E = any> {
     if (!this.head) return undefined;
     const removedNode = this.head;
     if (this.head === this.tail) {
-      this._head = null;
-      this._tail = null;
+      this._head = undefined;
+      this._tail = undefined;
     } else {
       this._head = removedNode.next;
-      this.head!.prev = null;
+      this.head!.prev = undefined;
     }
     this._length--;
     return removedNode.value;
@@ -262,8 +262,8 @@ export class DoublyLinkedList<E = any> {
    * Time Complexity: O(n), where n is the number of elements in the linked list.
    * Space Complexity: O(1)
    *
-   * The `getFirst` function returns the first node in a doubly linked list, or null if the list is empty.
-   * @returns The method `getFirst()` returns the first node of the doubly linked list, or `null` if the list is empty.
+   * The `getFirst` function returns the first node in a doubly linked list, or undefined if the list is empty.
+   * @returns The method `getFirst()` returns the first node of the doubly linked list, or `undefined` if the list is empty.
    */
   getFirst(): E | undefined {
     return this.head?.value;
@@ -278,8 +278,8 @@ export class DoublyLinkedList<E = any> {
    * Time Complexity: O(n), where n is the number of elements in the linked list.
    * Space Complexity: O(1)
    *
-   * The `getLast` function returns the last node in a doubly linked list, or null if the list is empty.
-   * @returns The method `getLast()` returns the last node of the doubly linked list, or `null` if the list is empty.
+   * The `getLast` function returns the last node in a doubly linked list, or undefined if the list is empty.
+   * @returns The method `getLast()` returns the last node of the doubly linked list, or `undefined` if the list is empty.
    */
   getLast(): E | undefined {
     return this.tail?.value;
@@ -294,11 +294,11 @@ export class DoublyLinkedList<E = any> {
    * Time Complexity: O(n), where n is the number of elements in the linked list.
    * Space Complexity: O(1)
    *
-   * The `getAt` function returns the value at a specified index in a linked list, or null if the index is out of bounds.
+   * The `getAt` function returns the value at a specified index in a linked list, or undefined if the index is out of bounds.
    * @param {number} index - The index parameter is a number that represents the position of the element we want to
    * retrieve from the list.
    * @returns The method is returning the value at the specified index in the linked list. If the index is out of bounds
-   * or the linked list is empty, it will return null.
+   * or the linked list is empty, it will return undefined.
    */
   getAt(index: number): E | undefined {
     if (index < 0 || index >= this.length) return undefined;
@@ -318,15 +318,15 @@ export class DoublyLinkedList<E = any> {
    * Time Complexity: O(n), where n is the number of elements in the linked list.
    * Space Complexity: O(1)
    *
-   * The function `getNodeAt` returns the node at a given index in a doubly linked list, or null if the index is out of
+   * The function `getNodeAt` returns the node at a given index in a doubly linked list, or undefined if the index is out of
    * range.
    * @param {number} index - The `index` parameter is a number that represents the position of the node we want to
    * retrieve from the doubly linked list. It indicates the zero-based index of the node we want to access.
    * @returns The method `getNodeAt(index: number)` returns a `DoublyLinkedListNode<E>` object if the index is within the
-   * valid range of the linked list, otherwise it returns `null`.
+   * valid range of the linked list, otherwise it returns `undefined`.
    */
-  getNodeAt(index: number): DoublyLinkedListNode<E> | null {
-    if (index < 0 || index >= this.length) return null;
+  getNodeAt(index: number): DoublyLinkedListNode<E> | undefined {
+    if (index < 0 || index >= this.length) return undefined;
     let current = this.head;
     for (let i = 0; i < index; i++) {
       current = current!.next;
@@ -344,12 +344,12 @@ export class DoublyLinkedList<E = any> {
    * Space Complexity: O(1)
    *
    * The function `findNodeByValue` searches for a node with a specific value in a doubly linked list and returns the
-   * node if found, otherwise it returns null.
+   * node if found, otherwise it returns undefined.
    * @param {E} value - The `value` parameter is the value that we want to search for in the doubly linked list.
    * @returns The function `findNodeByValue` returns a `DoublyLinkedListNode<E>` if a node with the specified value `value`
-   * is found in the linked list. If no such node is found, it returns `null`.
+   * is found in the linked list. If no such node is found, it returns `undefined`.
    */
-  getNode(value: E | null): DoublyLinkedListNode<E> | null {
+  getNode(value: E | undefined): DoublyLinkedListNode<E> | undefined {
     let current = this.head;
 
     while (current) {
@@ -359,7 +359,7 @@ export class DoublyLinkedList<E = any> {
       current = current.next;
     }
 
-    return null;
+    return undefined;
   }
 
   /**
@@ -502,7 +502,7 @@ export class DoublyLinkedList<E = any> {
    * The `deleteAt` function removes an element at a specified index from a linked list and returns the removed element.
    * @param {number} index - The index parameter represents the position of the element that needs to be deleted in the
    * data structure. It is of type number.
-   * @returns The method `deleteAt` returns the value of the node that was deleted, or `null` if the index is out of
+   * @returns The method `deleteAt` returns the value of the node that was deleted, or `undefined` if the index is out of
    * bounds.
    */
   deleteAt(index: number): E | undefined {
@@ -534,8 +534,8 @@ export class DoublyLinkedList<E = any> {
    * @returns The `delete` method returns a boolean value. It returns `true` if the value or node was successfully
    * deleted from the doubly linked list, and `false` if the value or node was not found in the list.
    */
-  delete(valOrNode: E | DoublyLinkedListNode<E> | null): boolean {
-    let node: DoublyLinkedListNode<E> | null;
+  delete(valOrNode: E | DoublyLinkedListNode<E> | undefined): boolean {
+    let node: DoublyLinkedListNode<E> | undefined;
 
     if (valOrNode instanceof DoublyLinkedListNode) {
       node = valOrNode;
@@ -569,11 +569,11 @@ export class DoublyLinkedList<E = any> {
   }
 
   /**
-   * The `clear` function resets the linked list by setting the head, tail, and length to null and 0 respectively.
+   * The `clear` function resets the linked list by setting the head, tail, and length to undefined and 0 respectively.
    */
   clear(): void {
-    this._head = null;
-    this._tail = null;
+    this._head = undefined;
+    this._tail = undefined;
     this._length = 0;
   }
 
@@ -590,9 +590,9 @@ export class DoublyLinkedList<E = any> {
    * @param callback - A function that takes a value of type E as its parameter and returns a boolean value. This
    * function is used to determine whether a particular value in the linked list satisfies a certain condition.
    * @returns The method `find` returns the first element in the linked list that satisfies the condition specified by
-   * the callback function. If no element satisfies the condition, it returns `null`.
+   * the callback function. If no element satisfies the condition, it returns `undefined`.
    */
-  find(callback: (value: E) => boolean): E | null {
+  find(callback: (value: E) => boolean): E | undefined {
     let current = this.head;
     while (current) {
       if (callback(current.value)) {
@@ -600,7 +600,7 @@ export class DoublyLinkedList<E = any> {
       }
       current = current.next;
     }
-    return null;
+    return undefined;
   }
 
   /**
@@ -641,13 +641,13 @@ export class DoublyLinkedList<E = any> {
    * Space Complexity: O(1)
    *
    * The `findBackward` function iterates through a linked list from the last node to the first node and returns the last
-   * value that satisfies the given callback function, or null if no value satisfies the callback.
+   * value that satisfies the given callback function, or undefined if no value satisfies the callback.
    * @param callback - A function that takes a value of type E as its parameter and returns a boolean value. This
    * function is used to determine whether a given value satisfies a certain condition.
    * @returns The method `findBackward` returns the last value in the linked list that satisfies the condition specified by
-   * the callback function. If no value satisfies the condition, it returns `null`.
+   * the callback function. If no value satisfies the condition, it returns `undefined`.
    */
-  findBackward(callback: (value: E) => boolean): E | null {
+  findBackward(callback: (value: E) => boolean): E | undefined {
     let current = this.tail;
     while (current) {
       if (callback(current.value)) {
@@ -655,7 +655,7 @@ export class DoublyLinkedList<E = any> {
       }
       current = current.prev;
     }
-    return null;
+    return undefined;
   }
 
   /**