data-structure-typed 1.47.7 → 1.47.8

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

@@ -61,14 +61,14 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * 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;
     /**
      * Time Complexity: O(|E|), where |E| is the number of edges incident to the given vertex.
      * Space Complexity: O(1)
@@ -81,9 +81,9 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * @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;
+    deleteEdgeBetween(v1: VO | VertexKey, v2: VO | VertexKey): EO | undefined;
     /**
      * Time Complexity: O(|E|), where |E| is the number of edges incident to the given vertex.
      * Space Complexity: O(1)
@@ -94,9 +94,9 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      *
      * 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;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -161,12 +161,12 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * 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;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -81,23 +81,23 @@ export class UndirectedGraph extends AbstractGraph {
      * 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, v2) {
         let edges = [];
-        if (v1 !== null && v2 !== null) {
+        if (v1 !== undefined && v2 !== undefined) {
             const vertex1 = this._getVertex(v1);
             const vertex2 = 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;
     }
     /**
      * Time Complexity: O(|E|), where |E| is the number of edges incident to the given vertex.
@@ -111,18 +111,18 @@ export class UndirectedGraph extends AbstractGraph {
      * @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, v2) {
         const vertex1 = this._getVertex(v1);
         const vertex2 = this._getVertex(v2);
         if (!vertex1 || !vertex2) {
-            return null;
+            return undefined;
         }
         const v1Edges = this._edges.get(vertex1);
-        let removed = null;
+        let removed = undefined;
         if (v1Edges) {
-            removed = arrayRemove(v1Edges, (e) => e.vertices.includes(vertex2.key))[0] || null;
+            removed = arrayRemove(v1Edges, (e) => e.vertices.includes(vertex2.key))[0] || undefined;
         }
         const v2Edges = this._edges.get(vertex2);
         if (v2Edges) {
@@ -140,7 +140,7 @@ export class UndirectedGraph extends AbstractGraph {
      *
      * 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) {
         return this.deleteEdgeBetween(edge.vertices[0], edge.vertices[1]);
@@ -246,14 +246,14 @@ export class UndirectedGraph extends AbstractGraph {
      * 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) {
         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]);
@@ -261,7 +261,7 @@ export class UndirectedGraph extends AbstractGraph {
             return [v1, v2];
         }
         else {
-            return null;
+            return undefined;
         }
     }
     /**
@@ -279,7 +279,7 @@ export class UndirectedGraph extends AbstractGraph {
     _addEdgeOnly(edge) {
         for (const end of edge.vertices) {
             const endVertex = this._getVertex(end);
-            if (endVertex === null)
+            if (endVertex === undefined)
                 return false;
             if (endVertex) {
                 const edges = this._edges.get(endVertex);

package/dist/mjs/data-structures/linked-list/doubly-linked-list.d.ts

@@ -7,8 +7,8 @@
  */
 export declare 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.
      * @param {E} value - The "value" parameter is the value that will be stored in the node. It can be of any data type, as it
@@ -21,10 +21,10 @@ export declare class DoublyLinkedList<E = any> {
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
     constructor(elements?: Iterable<E>);
-    protected _head: DoublyLinkedListNode<E> | null;
-    get head(): DoublyLinkedListNode<E> | null;
-    protected _tail: DoublyLinkedListNode<E> | null;
-    get tail(): DoublyLinkedListNode<E> | null;
+    protected _head: DoublyLinkedListNode<E> | undefined;
+    get head(): DoublyLinkedListNode<E> | undefined;
+    protected _tail: DoublyLinkedListNode<E> | undefined;
+    get tail(): DoublyLinkedListNode<E> | undefined;
     protected _length: number;
     get length(): number;
     get size(): number;
@@ -76,7 +76,7 @@ export declare 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;
     /**
@@ -89,7 +89,7 @@ export declare 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;
     /**
@@ -152,8 +152,8 @@ export declare 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;
     /**
@@ -164,8 +164,8 @@ export declare 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;
     /**
@@ -176,11 +176,11 @@ export declare 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;
     /**
@@ -191,14 +191,14 @@ export declare 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;
+    getNodeAt(index: number): DoublyLinkedListNode<E> | undefined;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
@@ -208,12 +208,12 @@ export declare 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;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
@@ -277,7 +277,7 @@ export declare 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;
@@ -295,14 +295,14 @@ export declare 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;
+    delete(valOrNode: E | DoublyLinkedListNode<E> | undefined): boolean;
     /**
      * The function checks if a variable has a length greater than zero and returns a boolean value.
      * @returns A boolean value is being returned.
      */
     isEmpty(): boolean;
     /**
-     * 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;
     /**
@@ -317,9 +317,9 @@ export declare 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;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
@@ -344,13 +344,13 @@ export declare 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;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)

package/dist/mjs/data-structures/linked-list/doubly-linked-list.js

@@ -16,8 +16,8 @@ export class DoublyLinkedListNode {
      */
     constructor(value) {
         this.value = value;
-        this.next = null;
-        this.prev = null;
+        this.next = undefined;
+        this.prev = undefined;
     }
 }
 export class DoublyLinkedList {
@@ -25,8 +25,8 @@ export class DoublyLinkedList {
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
     constructor(elements) {
-        this._head = null;
-        this._tail = null;
+        this._head = undefined;
+        this._tail = undefined;
         this._length = 0;
         if (elements) {
             for (const el of elements) {
@@ -117,19 +117,19 @@ export class DoublyLinkedList {
      *
      * 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() {
         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;
@@ -144,7 +144,7 @@ export class DoublyLinkedList {
      *
      * 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() {
         return this.pop();
@@ -166,12 +166,12 @@ export class DoublyLinkedList {
             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;
@@ -239,8 +239,8 @@ export class DoublyLinkedList {
      * 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() {
         return this.head?.value;
@@ -253,8 +253,8 @@ export class DoublyLinkedList {
      * 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() {
         return this.tail?.value;
@@ -267,11 +267,11 @@ export class DoublyLinkedList {
      * 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) {
         if (index < 0 || index >= this.length)
@@ -290,16 +290,16 @@ export class DoublyLinkedList {
      * 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) {
         if (index < 0 || index >= this.length)
-            return null;
+            return undefined;
         let current = this.head;
         for (let i = 0; i < index; i++) {
             current = current.next;
@@ -315,10 +315,10 @@ export class DoublyLinkedList {
      * 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) {
         let current = this.head;
@@ -328,7 +328,7 @@ export class DoublyLinkedList {
             }
             current = current.next;
         }
-        return null;
+        return undefined;
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
@@ -459,7 +459,7 @@ export class DoublyLinkedList {
      * 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) {
@@ -525,11 +525,11 @@ export class DoublyLinkedList {
         return this.length === 0;
     }
     /**
-     * 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() {
-        this._head = null;
-        this._tail = null;
+        this._head = undefined;
+        this._tail = undefined;
         this._length = 0;
     }
     /**
@@ -544,7 +544,7 @@ export class DoublyLinkedList {
      * @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) {
         let current = this.head;
@@ -554,7 +554,7 @@ export class DoublyLinkedList {
             }
             current = current.next;
         }
-        return null;
+        return undefined;
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
@@ -591,11 +591,11 @@ export class DoublyLinkedList {
      * 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) {
         let current = this.tail;
@@ -605,7 +605,7 @@ export class DoublyLinkedList {
             }
             current = current.prev;
         }
-        return null;
+        return undefined;
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.