data-structure-typed 1.47.7 → 1.47.9

package/src/data-structures/queue/queue.ts

@@ -15,8 +15,8 @@ export class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
   }
 
   /**
-   * 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(): E | undefined {
     return this.shift();
@@ -112,7 +112,7 @@ export class Queue<E = any> {
    *
    * 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(): E | undefined {
     if (this.size === 0) return undefined;
@@ -138,9 +138,9 @@ export class Queue<E = any> {
    * 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(): E | undefined {
     return this.size > 0 ? this.nodes[this.offset] : undefined;
@@ -155,9 +155,9 @@ export class Queue<E = any> {
    * 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(): E | undefined {
     return this.getFirst();
@@ -172,9 +172,9 @@ export class Queue<E = any> {
    * 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(): E | undefined {
     return this.size > 0 ? this.nodes[this.nodes.length - 1] : undefined;
@@ -189,9 +189,9 @@ export class Queue<E = any> {
    * 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(): E | undefined {
     return this.getLast();
@@ -222,8 +222,8 @@ export class Queue<E = any> {
    * 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(): E | undefined {
     return this.shift();

package/src/data-structures/stack/stack.ts

@@ -68,11 +68,11 @@ export 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 {
-    if (this.isEmpty()) return null;
+  peek(): E | undefined {
+    if (this.isEmpty()) return undefined;
 
     return this.elements[this.elements.length - 1];
   }
@@ -104,14 +104,14 @@ export 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 {
-    if (this.isEmpty()) return null;
+  pop(): E | undefined {
+    if (this.isEmpty()) return undefined;
 
-    return this.elements.pop() || null;
+    return this.elements.pop() || undefined;
   }
 
   /**

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

@@ -3,9 +3,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/test/integration/index.html

@@ -4,8 +4,8 @@
   <meta charset='UTF-8'>
   <title>CDN Test</title>
   <!--  <script src="../../dist/umd/data-structure-typed.min.js"></script>-->
-  <script src="../../dist/umd/data-structure-typed.js"></script>
-  <!--  <script src='https://cdn.jsdelivr.net/npm/data-structure-typed/dist/umd/data-structure-typed.min.js'></script>-->
+  <!--  <script src="../../dist/umd/data-structure-typed.js"></script>-->
+  <script src='https://cdn.jsdelivr.net/npm/data-structure-typed/dist/umd/data-structure-typed.min.js'></script>
   <!--  <script src='https://cdn.jsdelivr.net/npm/data-structure-typed@1.42.2/dist/umd/data-structure-typed.min.js'></script>-->
   <!--  <script src='https://cdn.jsdelivr.net/npm/data-structure-typed@1.43.3/dist/umd/data-structure-typed.min.js'></script>-->
   <!--  <script src='https://cdn.jsdelivr.net/npm/data-structure-typed@1.44.0/dist/umd/data-structure-typed.min.js'></script>-->
@@ -215,91 +215,160 @@
   } catch (e) {
     console.error(e);
   }
-  
+
   try {
-  const {
+    const {
       AVLTree,
-        BinaryTree,
-        BST,
-        Deque,
-        DoublyLinkedList,
-        HashMap,
-        Heap,
-        MaxPriorityQueue,
-        MinHeap,
-        MinPriorityQueue,
-        Queue,
-        RedBlackTree,
-        SinglyLinkedList,
-        Stack,
-        TreeMultimap,
-        Trie
+      BinaryTree,
+      BST,
+      Deque,
+      DoublyLinkedList,
+      HashMap,
+      Heap,
+      MaxPriorityQueue,
+      MinHeap,
+      MinPriorityQueue,
+      Queue,
+      RedBlackTree,
+      SinglyLinkedList,
+      Stack,
+      TreeMultimap,
+      Trie
     } = dataStructureTyped;
     const orgArr = [6, 1, 2, 7, 5, 3, 4, 9, 8];
     const orgStrArr = ["trie", "trial", "trick", "trip", "tree", "trend", "triangle", "track", "trace", "transmit"];
     const entries = [[6, 6], [1, 1], [2, 2], [7, 7], [5, 5], [3, 3], [4, 4], [9, 9], [8, 8]];
 
     const queue = new Queue(orgArr);
-    queue.print();
+    queue.print();      // [6, 1, 2, 7, 5, 3, 4, 9, 8]
 
     const deque = new Deque(orgArr);
-    deque.print();
+    deque.print();      // [6, 1, 2, 7, 5, 3, 4, 9, 8]
 
     const sList = new SinglyLinkedList(orgArr);
-    sList.print();
+    sList.print();      // [6, 1, 2, 7, 5, 3, 4, 9, 8]
 
     const dList = new DoublyLinkedList(orgArr);
-    dList.print();
+    dList.print();      // [6, 1, 2, 7, 5, 3, 4, 9, 8]
 
     const stack = new Stack(orgArr);
-    stack.print();
+    stack.print();      // [6, 1, 2, 7, 5, 3, 4, 9, 8]
 
     const minHeap = new MinHeap(orgArr);
-    minHeap.print();
+    minHeap.print();    // [1, 5, 2, 7, 6, 3, 4, 9, 8]
 
     const maxPQ = new MaxPriorityQueue(orgArr);
-    maxPQ.print();
+    maxPQ.print();      // [9, 8, 4, 7, 5, 2, 3, 1, 6]
 
     const biTree = new BinaryTree(entries);
     biTree.print();
+    //         ___6___
+    //        /       \
+    //     ___1_     _2_
+    //    /     \   /   \
+    //   _7_    5   3   4
+    //  /   \
+    //  9   8
 
     const bst = new BST(entries);
     bst.print();
+    //     _____5___
+    //    /         \
+    //   _2_       _7_
+    //  /   \     /   \
+    //  1   3_    6   8_
+    //        \         \
+    //        4         9
+
 
     const rbTree = new RedBlackTree(entries);
     rbTree.print();
+    //     ___4___
+    //    /       \
+    //   _2_     _6___
+    //  /   \   /     \
+    //  1   3   5    _8_
+    //              /   \
+    //              7   9
+
 
     const avl = new AVLTree(entries);
     avl.print();
+    //     ___4___
+    //    /       \
+    //   _2_     _6___
+    //  /   \   /     \
+    //  1   3   5    _8_
+    //              /   \
+    //              7   9
 
     const treeMulti = new TreeMultimap(entries);
     treeMulti.print();
+    //     ___4___
+    //    /       \
+    //   _2_     _6___
+    //  /   \   /     \
+    //  1   3   5    _8_
+    //              /   \
+    //              7   9
 
     const hm = new HashMap(entries);
-    hm.print()
+    hm.print()    // [[6, 6], [1, 1], [2, 2], [7, 7], [5, 5], [3, 3], [4, 4], [9, 9], [8, 8]]
+
     const rbTreeH = new RedBlackTree(hm);
     rbTreeH.print();
+    //     ___4___
+    //    /       \
+    //   _2_     _6___
+    //  /   \   /     \
+    //  1   3   5    _8_
+    //              /   \
+    //              7   9
 
     const pq = new MinPriorityQueue(orgArr);
-    pq.print();
+    pq.print();   // [1, 5, 2, 7, 6, 3, 4, 9, 8]
+
     const bst1 = new BST(pq);
     bst1.print();
+    //     _____5___
+    //    /         \
+    //   _2_       _7_
+    //  /   \     /   \
+    //  1   3_    6   8_
+    //        \         \
+    //        4         9
 
     const dq1 = new Deque(orgArr);
-    dq1.print();
+    dq1.print();    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
     const rbTree1 = new RedBlackTree(dq1);
     rbTree1.print();
+    //    _____5___
+    //   /         \
+    //  _2___     _7___
+    // /     \   /     \
+    // 1    _4   6    _9
+    //      /         /
+    //      3         8
+
 
     const trie2 = new Trie(orgStrArr);
-    trie2.print();
+    trie2.print();    // ['trie', 'trial', 'triangle', 'trick', 'trip', 'tree', 'trend', 'track', 'trace', 'transmit']
     const heap2 = new Heap(trie2, { comparator: (a, b) => Number(a) - Number(b) });
-    heap2.print();
+    heap2.print();    // ['transmit', 'trace', 'tree', 'trend', 'track', 'trial', 'trip', 'trie', 'trick', 'triangle']
     const dq2 = new Deque(heap2);
-    dq2.print();
+    dq2.print();      // ['transmit', 'trace', 'tree', 'trend', 'track', 'trial', 'trip', 'trie', 'trick', 'triangle']
     const entries2 = dq2.map((el, i) => [i, el]);
     const avl2 = new AVLTree(entries2);
     avl2.print();
-  }  catch (e) {
+    //     ___3_______
+    //    /           \
+    //   _1_       ___7_
+    //  /   \     /     \
+    //  0   2    _5_    8_
+    //          /   \     \
+    //          4   6     9
+
+  } catch (e) {
     console.error(e);
   }
 </script>

package/test/performance/data-structures/linked-list/doubly-linked-list.test.ts

@@ -57,7 +57,7 @@ suite
   })
   .add(`${LINEAR.toLocaleString()} insertBefore`, () => {
     const doublyList = new DoublyLinkedList<number>();
-    let midNode: DoublyLinkedListNode | null = null;
+    let midNode: DoublyLinkedListNode | undefined;
     const midIndex = Math.floor(LINEAR / 2);
     for (let i = 0; i < LINEAR; i++) {
       doublyList.push(i);

package/test/performance/data-structures/linked-list/singly-linked-list.test.ts

@@ -19,7 +19,7 @@ suite
   })
   .add(`${TEN_THOUSAND.toLocaleString()} insertBefore`, () => {
     const singlyList = new SinglyLinkedList<number>();
-    let midSinglyNode: SinglyLinkedListNode | null = null;
+    let midSinglyNode: SinglyLinkedListNode | undefined;
     const midIndex = Math.floor(TEN_THOUSAND / 2);
     for (let i = 0; i < TEN_THOUSAND; i++) {
       singlyList.push(i);

package/test/unit/data-structures/binary-tree/segment-tree.test.ts

@@ -37,7 +37,7 @@ describe('SegmentTree', () => {
   it('should handle an empty input array', () => {
     // Check behavior when dealing with an empty input array
     const emptySegmentTree = new SegmentTree([]);
-    expect(emptySegmentTree.root).toBe(null);
+    expect(emptySegmentTree.root).toBe(undefined);
     expect(emptySegmentTree.querySumByRange(0, 2)).toBe(0); // Sum of an empty array should be 0
   });
 

package/test/unit/data-structures/graph/abstract-graph.test.ts

@@ -36,11 +36,11 @@ class MyGraph<
     return new MyEdge(srcOrV1, destOrV2, weight, value) as EO;
   }
 
-  deleteEdge(edge: EO): EO | null {
+  deleteEdge(edge: EO): EO | undefined {
     return edge;
   }
 
-  getEdge(srcOrKey: VertexKey, destOrKey: VertexKey): EO | null {
+  getEdge(srcOrKey: VertexKey, destOrKey: VertexKey): EO | undefined {
     return new MyEdge(srcOrKey, destOrKey) as EO;
   }
 
@@ -62,8 +62,8 @@ class MyGraph<
     return [new MyVertex(a, 'b') as VO];
   }
 
-  getEndsOfEdge(edge: EO): [VO, VO] | null {
-    return edge ? null : null;
+  getEndsOfEdge(edge: EO): [VO, VO] | undefined {
+    return edge ? undefined : undefined;
   }
 
   protected _addEdgeOnly(edge: EO): boolean {

package/test/unit/data-structures/graph/directed-graph.test.ts

@@ -196,7 +196,7 @@ describe('Inherit from DirectedGraph and perform operations', () => {
       expect(edge1).toBeInstanceOf(MyEdge);
       expect(edge1.src).toBe(1);
       expect(edge1).toEqual(edge2);
-      expect(edge3).toBeNull();
+      expect(edge3).toBe(undefined);
     }
   });
 
@@ -217,7 +217,7 @@ describe('Inherit from DirectedGraph and perform operations', () => {
       removedEdge && expect(removedEdge.value).toBe('edge-data1-2');
       removedEdge && expect(removedEdge.src).toBe(1);
     }
-    expect(edgeAfterRemoval).toBeNull();
+    expect(edgeAfterRemoval).toBe(undefined);
   });
 
   it('Topological sort', () => {
@@ -303,7 +303,7 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
 
     myGraph.addEdge(new MyEdge(7, 3, 73, 'edge-data7-3'));
     const topologicalSorted = myGraph.topologicalSort();
-    expect(topologicalSorted).toBeNull();
+    expect(topologicalSorted).toBe(undefined);
 
     const minPath1to7 = myGraph.getMinPathBetween(1, 7);
 
@@ -378,11 +378,11 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
 
       expect(predecessor).toBeInstanceOf(Array);
       expect(predecessor.length).toBe(9);
-      expect(predecessor[0]).toEqual([vertex2, null, vertex2, null, vertex3, null, vertex4, null, null]);
-      expect(predecessor[1]).toEqual([null, vertex1, null, vertex1, vertex3, null, vertex4, null, vertex1]);
-      expect(predecessor[5]).toEqual([null, null, null, null, null, null, null, null, null]);
-      expect(predecessor[7]).toEqual([null, null, null, null, null, null, null, null, null]);
-      expect(predecessor[8]).toEqual([vertex7, vertex7, vertex7, vertex7, vertex7, null, null, null, vertex7]);
+      expect(predecessor[0]).toEqual([vertex2, undefined, vertex2, undefined, vertex3, undefined, vertex4, undefined, undefined]);
+      expect(predecessor[1]).toEqual([undefined, vertex1, undefined, vertex1, vertex3, undefined, vertex4, undefined, vertex1]);
+      expect(predecessor[5]).toEqual([undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined]);
+      expect(predecessor[7]).toEqual([undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined]);
+      expect(predecessor[8]).toEqual([vertex7, vertex7, vertex7, vertex7, vertex7, undefined, undefined, undefined, vertex7]);
     }
 
     const dijkstraRes12tt = myGraph.dijkstra(1, 2, true, true);
@@ -436,7 +436,7 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
       expect(paths[8][1]).toBe(vertex9);
     }
 
-    const dijkstraRes1ntt = myGraph.dijkstra(1, null, true, true);
+    const dijkstraRes1ntt = myGraph.dijkstra(1, undefined, true, true);
 
     expect(dijkstraRes1ntt).toBeTruthy();
     if (dijkstraRes1ntt) {
@@ -499,7 +499,7 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
       expect(paths[8][1]).toBe(vertex9);
     }
 
-    const dijkstraWithoutHeapRes1ntt = myGraph.dijkstraWithoutHeap(1, null, true, true);
+    const dijkstraWithoutHeapRes1ntt = myGraph.dijkstraWithoutHeap(1, undefined, true, true);
     expect(dijkstraWithoutHeapRes1ntt).toBeTruthy();
     if (dijkstraWithoutHeapRes1ntt) {
       const { distMap, minDist, minPath, paths } = dijkstraWithoutHeapRes1ntt;
@@ -595,3 +595,44 @@ describe('cycles, strongly connected components, bridges, articular points in Di
   expect(dfnMap.size).toBe(8);
   expect(lowMap.size).toBe(8);
 });
+
+describe('DirectedGraph iterative Methods', () => {
+  let graph: DirectedGraph<string>;
+  let vertices: string[];
+
+  beforeEach(() => {
+    graph = new DirectedGraph();
+    vertices = ['A', 'B', 'C', 'D'];
+    vertices.forEach(vertex => graph.addVertex(vertex));
+  });
+
+  test('[Symbol.iterator] should iterate over all vertices', () => {
+    const iteratedVertices = [];
+    for (const vertex of graph) {
+      iteratedVertices.push(vertex[0]);
+    }
+    expect(iteratedVertices).toEqual(vertices);
+  });
+
+  test('forEach should apply a function to each vertex', () => {
+    const result: VertexKey[] = [];
+    graph.forEach(vertex => result.push(vertex[0]));
+    expect(result).toEqual(vertices);
+  });
+
+  test('filter should return vertices that satisfy the condition', () => {
+    const filtered = graph.filter(vertex => vertex[0] === 'A' || vertex[0] === 'B');
+    expect(filtered).toEqual([["A", undefined], ["B", undefined]]);
+  });
+
+  test('map should apply a function to each vertex and return a new array', () => {
+    const mapped = graph.map(vertex => vertex[0] + '_mapped');
+    expect(mapped).toEqual(vertices.map(v => v + '_mapped'));
+  });
+
+  test('reduce should accumulate a value based on each vertex', () => {
+    const concatenated = graph.reduce((acc, vertex) => acc + vertex[0], '');
+    expect(concatenated).toBe(vertices.join(''));
+  });
+});
+

package/test/unit/data-structures/graph/undirected-graph.test.ts

@@ -10,11 +10,11 @@ describe('UndirectedGraph Operation Test', () => {
   });
 
   it('should edge cases', () => {
-    expect(graph.deleteEdge(new UndirectedEdge('c', 'd'))).toBe(null);
-    expect(graph.deleteEdgeBetween('c', 'd')).toBe(null);
+    expect(graph.deleteEdge(new UndirectedEdge('c', 'd'))).toBe(undefined);
+    expect(graph.deleteEdgeBetween('c', 'd')).toBe(undefined);
     expect(graph.degreeOf('c')).toBe(0);
     expect(graph.edgesOf('c').length).toBe(0);
-    expect(graph.getEndsOfEdge(new UndirectedEdge('c', 'd'))).toBe(null);
+    expect(graph.getEndsOfEdge(new UndirectedEdge('c', 'd'))).toBe(undefined);
   });
 
   it('should add vertices', () => {

package/test/unit/data-structures/linked-list/doubly-linked-list.test.ts

@@ -17,8 +17,8 @@ describe('DoublyLinkedList Operation Test', () => {
   });
 
   it('should out of bound index', () => {
-    expect(list.getNodeAt(-1)).toBe(null);
-    expect(list.getNodeAt(5)).toBe(null);
+    expect(list.getNodeAt(-1)).toBe(undefined);
+    expect(list.getNodeAt(5)).toBe(undefined);
     expect(list.insertAt(5, 6)).toBe(true);
   });
 
@@ -37,16 +37,16 @@ describe('DoublyLinkedList Operation Test', () => {
     expect(list.tail?.value).toBe(4);
   });
 
-  it('should find null', () => {
-    expect(list.find(value => value === 6)).toBe(null);
+  it('should find undefined', () => {
+    expect(list.find(value => value === 6)).toBe(undefined);
   });
 
   it('should indexOf -1', () => {
     expect(list.indexOf(6)).toBe(-1);
   });
 
-  it('should findBackward null', () => {
-    expect(list.findBackward(value => value === 0)).toBe(null);
+  it('should findBackward undefined', () => {
+    expect(list.findBackward(value => value === 0)).toBe(undefined);
   });
 
   it('should insertAfter tail', () => {
@@ -69,8 +69,8 @@ describe('DoublyLinkedList Operation Test', () => {
 
   it('should initialize an empty list', () => {
     expect(list.length).toBe(0);
-    expect(list.head).toBeNull();
-    expect(list.tail).toBeNull();
+    expect(list.head).toBe(undefined);
+    expect(list.tail).toBe(undefined);
   });
 
   it('should push elements to the list', () => {
@@ -134,8 +134,8 @@ describe('DoublyLinkedList Operation Test', () => {
     // Deleting from the end
     list.deleteAt(0);
     expect(list.length).toBe(0);
-    expect(list.head).toBeNull();
-    expect(list.tail).toBeNull();
+    expect(list.head).toBe(undefined);
+    expect(list.tail).toBe(undefined);
   });
 
   it('should delete elements by value', () => {
@@ -154,8 +154,8 @@ describe('DoublyLinkedList Operation Test', () => {
 
     list.delete(3);
     expect(list.length).toBe(0);
-    expect(list.head).toBeNull();
-    expect(list.tail).toBeNull();
+    expect(list.head).toBe(undefined);
+    expect(list.tail).toBe(undefined);
   });
 
   it('should reverse the linked list', () => {
@@ -259,8 +259,8 @@ describe('DoublyLinkedList Operation Test', () => {
     list.clear();
 
     expect(list.length).toBe(0);
-    expect(list.head).toBe(null);
-    expect(list.tail).toBe(null);
+    expect(list.head).toBe(undefined);
+    expect(list.tail).toBe(undefined);
   });
 
   it('should create a reversed array of values', () => {

package/test/unit/data-structures/linked-list/singly-linked-list.test.ts

@@ -333,7 +333,7 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(1);
       list.push(3);
       const result = list.find(data => data % 2 === 0);
-      expect(result).toBeNull();
+      expect(result).toBe(undefined);
     });
   });
 
@@ -402,8 +402,8 @@ describe('SinglyLinkedList', () => {
   });
 
   it('should initialize an empty list', () => {
-    expect(list.head).toBeNull();
-    expect(list.tail).toBeNull();
+    expect(list.head).toBe(undefined);
+    expect(list.tail).toBe(undefined);
     expect(list.length).toBe(0);
   });
 

package/test/unit/data-structures/linked-list/skip-list.test.ts

@@ -81,6 +81,6 @@ describe('SkipList', () => {
 
   it('lower(key) should return the getLast element less than the given key', () => {
     expect(skipList.lower(2)).toBe('One');
-    expect(skipList.lower(1)).toBe(null);
+    expect(skipList.lower(1)).toBe(undefined);
   });
 });

package/test/unit/data-structures/queue/deque.test.ts

@@ -154,7 +154,7 @@ describe('Deque', () => {
     expect(deque.getAt(2)).toBe(3);
   });
 
-  it('should return null for out-of-bounds index', () => {
+  it('should return undefined for out-of-bounds index', () => {
     // expect(deque.getAt(0)).toThrowError('Index out of bounds.');
     // expect(deque.getAt(1)).toThrow('Index out of bounds');
     // expect(deque.getAt(-1)).toThrow('Index out of bounds');

package/test/unit/data-structures/stack/stack.test.ts

@@ -35,9 +35,9 @@ describe('Stack', () => {
     expect(stack.size).toBe(2);
   });
 
-  it('should return null when popping from an empty stack', () => {
+  it('should return undefined when popping from an empty stack', () => {
     const poppedElement = stack.pop();
-    expect(poppedElement).toBeNull();
+    expect(poppedElement).toBe(undefined);
   });
 
   it('should convert the stack to an array', () => {