data-structure-typed 1.47.6 → 1.47.8

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

@@ -7,10 +7,10 @@ describe('BST operations test', () => {
   it('should perform various operations on a Binary Search Tree with numeric values', () => {
     const bst = new BST();
     expect(bst).toBeInstanceOf(BST);
-    bst.add(11, 11);
-    bst.add(3, 3);
-    const idsAndValues = [15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-    bst.addMany(idsAndValues, idsAndValues, false);
+    bst.add([11, 11]);
+    bst.add([3, 3]);
+    const idsAndValues: [number, number][] = [[15, 15], [1, 1], [8, 8], [13, 13], [16, 16], [2, 2], [6, 6], [9, 9], [12, 12], [14, 14], [4, 4], [7, 7], [10, 10], [5, 5]];
+    bst.addMany(idsAndValues, false);
     expect(bst.root).toBeInstanceOf(BSTNode);
 
     if (bst.root) expect(bst.root.key).toBe(11);
@@ -191,30 +191,26 @@ describe('BST operations test', () => {
   it('should perform various operations on a Binary Search Tree with object values', () => {
     const objBST = new BST<{ key: number; keyA: number }>();
     expect(objBST).toBeInstanceOf(BST);
-    objBST.add(11, { key: 11, keyA: 11 });
-    objBST.add(3, { key: 3, keyA: 3 });
-    const values = [
-      { key: 15, keyA: 15 },
-      { key: 1, keyA: 1 },
-      { key: 8, keyA: 8 },
-      { key: 13, keyA: 13 },
-      { key: 16, keyA: 16 },
-      { key: 2, keyA: 2 },
-      { key: 6, keyA: 6 },
-      { key: 9, keyA: 9 },
-      { key: 12, keyA: 12 },
-      { key: 14, keyA: 14 },
-      { key: 4, keyA: 4 },
-      { key: 7, keyA: 7 },
-      { key: 10, keyA: 10 },
-      { key: 5, keyA: 5 }
+    objBST.add([11, { key: 11, keyA: 11 }]);
+    objBST.add([3, { key: 3, keyA: 3 }]);
+    const values: [number, { key: number; keyA: number }][] = [
+      [15, { key: 15, keyA: 15 }],
+      [1, { key: 1, keyA: 1 }],
+      [8, { key: 8, keyA: 8 }],
+      [13, { key: 13, keyA: 13 }],
+      [16, { key: 16, keyA: 16 }],
+      [2, { key: 2, keyA: 2 }],
+      [6, { key: 6, keyA: 6 }],
+      [9, { key: 9, keyA: 9 }],
+      [12, { key: 12, keyA: 12 }],
+      [14, { key: 14, keyA: 14 }],
+      [4, { key: 4, keyA: 4 }],
+      [7, { key: 7, keyA: 7 }],
+      [10, { key: 10, keyA: 10 }],
+      [5, { key: 5, keyA: 5 }]
     ];
 
-    objBST.addMany(
-      values.map(item => item.key),
-      values,
-      false
-    );
+    objBST.addMany(values, false);
 
     expect(objBST.root).toBeInstanceOf(BSTNode);
 
@@ -395,12 +391,12 @@ describe('BST operations test', () => {
 
 describe('BST operations test recursively', () => {
   it('should perform various operations on a Binary Search Tree with numeric values', () => {
-    const bst = new BST([], { iterationType: IterationType.RECURSIVE });
+    const bst = new BST<number>([], { iterationType: IterationType.RECURSIVE });
     expect(bst).toBeInstanceOf(BST);
-    bst.add(11, 11);
-    bst.add(3, 3);
+    bst.add([11, 11]);
+    bst.add([3, 3]);
     const idsAndValues = [15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-    bst.addMany(idsAndValues, idsAndValues, false);
+    bst.addMany(idsAndValues, false);
     expect(bst.root).toBeInstanceOf(BSTNode);
 
     if (bst.root) expect(bst.root.key).toBe(11);
@@ -414,11 +410,11 @@ describe('BST operations test recursively', () => {
     expect(node6 && bst.getDepth(6)).toBe(3);
 
     const nodeId10 = bst.getNode(10);
-    expect(bst.get(10)).toBe(10);
+    expect(bst.get(10)).toBe(undefined);
     expect(nodeId10?.key).toBe(10);
 
     const nodeVal9 = bst.getNode(9, node => node.value);
-    expect(nodeVal9?.key).toBe(9);
+    expect(nodeVal9?.key).toBe(undefined);
 
     const leftMost = bst.getLeftMost();
     expect(leftMost?.key).toBe(1);
@@ -582,27 +578,26 @@ describe('BST operations test recursively', () => {
   it('should perform various operations on a Binary Search Tree with object values', () => {
     const objBST = new BST<{ key: number; keyA: number }>();
     expect(objBST).toBeInstanceOf(BST);
-    objBST.add(11, { key: 11, keyA: 11 });
-    objBST.add(3, { key: 3, keyA: 3 });
-    const values = [
-      { key: 15, keyA: 15 },
-      { key: 1, keyA: 1 },
-      { key: 8, keyA: 8 },
-      { key: 13, keyA: 13 },
-      { key: 16, keyA: 16 },
-      { key: 2, keyA: 2 },
-      { key: 6, keyA: 6 },
-      { key: 9, keyA: 9 },
-      { key: 12, keyA: 12 },
-      { key: 14, keyA: 14 },
-      { key: 4, keyA: 4 },
-      { key: 7, keyA: 7 },
-      { key: 10, keyA: 10 },
-      { key: 5, keyA: 5 }
+    objBST.add([11, { key: 11, keyA: 11 }]);
+    objBST.add([3, { key: 3, keyA: 3 }]);
+    const values: [number, { key: number; keyA: number }][] = [
+      [15, { key: 15, keyA: 15 }],
+      [1, { key: 1, keyA: 1 }],
+      [8, { key: 8, keyA: 8 }],
+      [13, { key: 13, keyA: 13 }],
+      [16, { key: 16, keyA: 16 }],
+      [2, { key: 2, keyA: 2 }],
+      [6, { key: 6, keyA: 6 }],
+      [9, { key: 9, keyA: 9 }],
+      [12, { key: 12, keyA: 12 }],
+      [14, { key: 14, keyA: 14 }],
+      [4, { key: 4, keyA: 4 }],
+      [7, { key: 7, keyA: 7 }],
+      [10, { key: 10, keyA: 10 }],
+      [5, { key: 5, keyA: 5 }]
     ];
 
     objBST.addMany(
-      values.map(item => item.key),
       values,
       false
     );
@@ -834,7 +829,7 @@ describe('BST Performance test', function () {
 
   it('should the lastKey of a BST to be the largest key', function () {
     const bst = new BST();
-    bst.addMany([9, 8, 7, 3, 1, 2, 5, 4, 6], undefined, false);
+    bst.addMany([9, 8, 7, 3, 1, 2, 5, 4, 6], false);
     expect(bst.lastKey()).toBe(9);
   });
 
@@ -856,9 +851,9 @@ describe('BST iterative methods test', () => {
   let bst: BST<string>;
   beforeEach(() => {
     bst = new BST();
-    bst.add(1, 'a');
-    bst.add(2, 'b');
-    bst.add(3, 'c');
+    bst.add([1, 'a']);
+    bst.add([2, 'b']);
+    bst.add([3, 'c']);
   });
 
   test('The node obtained by get Node should match the node type', () => {

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

@@ -5,7 +5,7 @@ describe('Overall BinaryTree Test', () => {
     const bst = new BST();
     bst.add(11);
     bst.add(3);
-    bst.addMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5], undefined, false);
+    bst.addMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5], false);
     bst.size === 16; // true
     expect(bst.size).toBe(16); // true
     bst.has(6); // true
@@ -30,26 +30,25 @@ describe('Overall BinaryTree Test', () => {
     expect(bfsIDs[0]).toBe(11);
 
     const objBST = new BST<{ key: number; keyA: number }>();
-    objBST.add(11, { key: 11, keyA: 11 });
-    objBST.add(3, { key: 3, keyA: 3 });
+    objBST.add([11, { key: 11, keyA: 11 }]);
+    objBST.add([3, { key: 3, keyA: 3 }]);
 
     objBST.addMany(
-      [15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5],
       [
-        { key: 15, keyA: 15 },
-        { key: 1, keyA: 1 },
-        { key: 8, keyA: 8 },
-        { key: 13, keyA: 13 },
-        { key: 16, keyA: 16 },
-        { key: 2, keyA: 2 },
-        { key: 6, keyA: 6 },
-        { key: 9, keyA: 9 },
-        { key: 12, keyA: 12 },
-        { key: 14, keyA: 14 },
-        { key: 4, keyA: 4 },
-        { key: 7, keyA: 7 },
-        { key: 10, keyA: 10 },
-        { key: 5, keyA: 5 }
+        [15, { key: 15, keyA: 15 }],
+        [1, { key: 1, keyA: 1 }],
+        [8, { key: 8, keyA: 8 }],
+        [13, { key: 13, keyA: 13 }],
+        [16, { key: 16, keyA: 16 }],
+        [2, { key: 2, keyA: 2 }],
+        [6, { key: 6, keyA: 6 }],
+        [9, { key: 9, keyA: 9 }],
+        [12, { key: 12, keyA: 12 }],
+        [14, { key: 14, keyA: 14 }],
+        [4, { key: 4, keyA: 4 }],
+        [7, { key: 7, keyA: 7 }],
+        [10, { key: 10, keyA: 10 }],
+        [5, { key: 5, keyA: 5 }]
       ]
     );
 

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

@@ -510,9 +510,9 @@ describe('RedBlackTree iterative methods test', () => {
   let rbTree: RedBlackTree<string>;
   beforeEach(() => {
     rbTree = new RedBlackTree();
-    rbTree.add(1, 'a');
-    rbTree.add(2, 'b');
-    rbTree.add(3, 'c');
+    rbTree.add([1, 'a']);
+    rbTree.add([2, 'b']);
+    rbTree.add([3, 'c']);
   });
 
   test('The node obtained by get Node should match the node type', () => {

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/binary-tree/tree-multimap.test.ts

@@ -3,15 +3,52 @@ import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
 
-describe('TreeMultimap operations test', () => {
-  it('should perform various operations on a Binary Search Tree with numeric values', () => {
+describe('TreeMultimap count', () => {
+  let tm: TreeMultimap<number>;
+  beforeEach(() => {
+    tm = new TreeMultimap<number>();
+
+  })
+  it('Should added isolated node count ', () => {
+    tm.addMany([[1, 1], [2, 2], [3, 3], [4, 4], [5, 5]]);
+    const newNode = new TreeMultimapNode(3, 33, 10);
+    tm.add(newNode);
+    expect(tm.count).toBe(15)
+  })
+
+  it('Should count', () => {
+    tm.addMany([[1, 1], [2, 2], [3, 3]]);
+    tm.lesserOrGreaterTraverse(node => node.count += 2, CP.gt, 1);
+    expect(tm.count).toBe(7)
+  })
+})
+
+describe('TreeMultimap operations test1', () => {
+  it('should perform various operations on a Binary Search Tree with numeric values1', () => {
     const treeMultimap = new TreeMultimap();
 
     expect(treeMultimap instanceof TreeMultimap);
-    treeMultimap.add(11, 11);
-    treeMultimap.add(3, 3);
-    const idAndValues = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-    treeMultimap.addMany(idAndValues, idAndValues);
+    treeMultimap.add([11, 11]);
+    treeMultimap.add([3, 3]);
+    const idAndValues: [number, number][] = [
+      [11, 11],
+      [3, 3],
+      [15, 15],
+      [1, 1],
+      [8, 8],
+      [13, 13],
+      [16, 16],
+      [2, 2],
+      [6, 6],
+      [9, 9],
+      [12, 12],
+      [14, 14],
+      [4, 4],
+      [7, 7],
+      [10, 10],
+      [5, 5]
+    ];
+    treeMultimap.addMany(idAndValues);
     expect(treeMultimap.root instanceof TreeMultimapNode);
 
     if (treeMultimap.root) expect(treeMultimap.root.key == 11);
@@ -21,8 +58,8 @@ describe('TreeMultimap operations test', () => {
 
     expect(treeMultimap.has(6));
 
-    expect(treeMultimap.getHeight(6)).toBe(3);
-    expect(treeMultimap.getDepth(6)).toBe(1);
+    expect(treeMultimap.getHeight(6)).toBe(4);
+    expect(treeMultimap.getDepth(6)).toBe(0);
     const nodeId10 = treeMultimap.getNode(10);
     expect(nodeId10?.key).toBe(10);
 
@@ -39,14 +76,14 @@ describe('TreeMultimap operations test', () => {
 
     const node15 = treeMultimap.getNode(15);
     const minNodeBySpecificNode = node15 && treeMultimap.getLeftMost(node15);
-    expect(minNodeBySpecificNode?.key).toBe(12);
+    expect(minNodeBySpecificNode?.key).toBe(15);
 
     let subTreeSum = 0;
     node15 && treeMultimap.subTreeTraverse((node: TreeMultimapNode<number>) => (subTreeSum += node.key), 15);
-    expect(subTreeSum).toBe(70);
+    expect(subTreeSum).toBe(31);
     let lesserSum = 0;
     treeMultimap.lesserOrGreaterTraverse((node: TreeMultimapNode<number>) => (lesserSum += node.key), CP.lt, 10);
-    expect(lesserSum).toBe(45);
+    expect(lesserSum).toBe(21);
 
     expect(node15 instanceof TreeMultimapNode);
     if (node15 instanceof TreeMultimapNode) {
@@ -203,39 +240,38 @@ describe('TreeMultimap operations test', () => {
     expect(bfsNodes[1].key).toBe(2);
     expect(bfsNodes[2].key).toBe(16);
 
-    expect(treeMultimap.count).toBe(9);
+    expect(treeMultimap.count).toBe(4);
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
     const objTreeMultimap = new TreeMultimap<{ key: number; keyA: number }>();
     expect(objTreeMultimap).toBeInstanceOf(TreeMultimap);
-    objTreeMultimap.add(11, { key: 11, keyA: 11 });
-    objTreeMultimap.add(3, { key: 3, keyA: 3 });
-    const values = [
-      { key: 15, keyA: 15 },
-      { key: 1, keyA: 1 },
-      { key: 8, keyA: 8 },
-      { key: 13, keyA: 13 },
-      { key: 16, keyA: 16 },
-      { key: 2, keyA: 2 },
-      { key: 6, keyA: 6 },
-      { key: 9, keyA: 9 },
-      { key: 12, keyA: 12 },
-      { key: 14, keyA: 14 },
-      { key: 4, keyA: 4 },
-      { key: 7, keyA: 7 },
-      { key: 10, keyA: 10 },
-      { key: 5, keyA: 5 }
+    objTreeMultimap.add([11, { key: 11, keyA: 11 }]);
+    objTreeMultimap.add([3, { key: 3, keyA: 3 }]);
+    const values: [number, { key: number, keyA: number }][] = [
+      [15, { key: 15, keyA: 15 }],
+      [1, { key: 1, keyA: 1 }],
+      [8, { key: 8, keyA: 8 }],
+      [13, { key: 13, keyA: 13 }],
+      [16, { key: 16, keyA: 16 }],
+      [2, { key: 2, keyA: 2 }],
+      [6, { key: 6, keyA: 6 }],
+      [9, { key: 9, keyA: 9 }],
+      [12, { key: 12, keyA: 12 }],
+      [14, { key: 14, keyA: 14 }],
+      [4, { key: 4, keyA: 4 }],
+      [7, { key: 7, keyA: 7 }],
+      [10, { key: 10, keyA: 10 }],
+      [5, { key: 5, keyA: 5 }]
     ];
 
     objTreeMultimap.addMany(
-      values.map(item => item.key),
       values
     );
 
     expect(objTreeMultimap.root).toBeInstanceOf(TreeMultimapNode);
 
-    if (objTreeMultimap.root) expect(objTreeMultimap.root.key).toBe(11);
+    if (objTreeMultimap.root) expect(objTreeMultimap.root.key).toBe(6);
 
     expect(objTreeMultimap.count).toBe(16);
 
@@ -243,26 +279,43 @@ describe('TreeMultimap operations test', () => {
   });
 });
 
-describe('TreeMultimap operations test recursively', () => {
-  it('should perform various operations on a Binary Search Tree with numeric values', () => {
-    const treeMultimap = new TreeMultimap([], { iterationType: IterationType.RECURSIVE });
+describe('TreeMultimap operations test recursively1', () => {
+  it('should perform various operations on a Binary Search Tree with numeric values1', () => {
+    const treeMultimap = new TreeMultimap<number>([], { iterationType: IterationType.RECURSIVE });
 
     expect(treeMultimap instanceof TreeMultimap);
-    treeMultimap.add(11, 11);
-    treeMultimap.add(3, 3);
-    const idAndValues = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-    treeMultimap.addMany(idAndValues, idAndValues);
-    expect(treeMultimap.root instanceof TreeMultimapNode);
+    treeMultimap.add([11, 11]);
+    treeMultimap.add([3, 3]);
+    const idAndValues: [number, number][] = [
+      [11, 11],
+      [3, 3],
+      [15, 15],
+      [1, 1],
+      [8, 8],
+      [13, 13],
+      [16, 16],
+      [2, 2],
+      [6, 6],
+      [9, 9],
+      [12, 12],
+      [14, 14],
+      [4, 4],
+      [7, 7],
+      [10, 10],
+      [5, 5]
+    ];
+    treeMultimap.addMany(idAndValues);
+    expect(treeMultimap.root).toBeInstanceOf(TreeMultimapNode);
 
-    if (treeMultimap.root) expect(treeMultimap.root.key == 11);
+    if (treeMultimap.root) expect(treeMultimap.root.key).toBe(6);
 
     expect(treeMultimap.size).toBe(16);
     expect(treeMultimap.count).toBe(18);
 
     expect(treeMultimap.has(6));
 
-    expect(treeMultimap.getHeight(6)).toBe(3);
-    expect(treeMultimap.getDepth(6)).toBe(1);
+    expect(treeMultimap.getHeight(6)).toBe(4);
+    expect(treeMultimap.getDepth(6)).toBe(0);
     const nodeId10 = treeMultimap.getNode(10);
     expect(nodeId10?.key).toBe(10);
 
@@ -279,14 +332,14 @@ describe('TreeMultimap operations test recursively', () => {
 
     const node15 = treeMultimap.getNode(15);
     const minNodeBySpecificNode = node15 && treeMultimap.getLeftMost(node15);
-    expect(minNodeBySpecificNode?.key).toBe(12);
+    expect(minNodeBySpecificNode?.key).toBe(15);
 
     let subTreeSum = 0;
     node15 && treeMultimap.subTreeTraverse((node: TreeMultimapNode<number>) => (subTreeSum += node.key), 15);
-    expect(subTreeSum).toBe(70);
+    expect(subTreeSum).toBe(31);
     let lesserSum = 0;
     treeMultimap.lesserOrGreaterTraverse((node: TreeMultimapNode<number>) => (lesserSum += node.key), CP.lt, 10);
-    expect(lesserSum).toBe(45);
+    expect(lesserSum).toBe(21);
 
     expect(node15 instanceof TreeMultimapNode);
     if (node15 instanceof TreeMultimapNode) {
@@ -303,7 +356,7 @@ describe('TreeMultimap operations test recursively', () => {
     const dfsInorderNodes = treeMultimap.dfs(node => node, 'in');
     expect(dfsInorderNodes[0].key).toBe(1);
     expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
-    expect(treeMultimap.isPerfectlyBalanced()).toBe(false);
+    expect(treeMultimap.isPerfectlyBalanced()).toBe(true);
 
     treeMultimap.perfectlyBalance();
 
@@ -443,39 +496,38 @@ describe('TreeMultimap operations test recursively', () => {
     expect(bfsNodes[1].key).toBe(2);
     expect(bfsNodes[2].key).toBe(16);
 
-    expect(treeMultimap.count).toBe(9);
+    expect(treeMultimap.count).toBe(4);
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
     const objTreeMultimap = new TreeMultimap<{ key: number; keyA: number }>();
     expect(objTreeMultimap).toBeInstanceOf(TreeMultimap);
-    objTreeMultimap.add(11, { key: 11, keyA: 11 });
-    objTreeMultimap.add(3, { key: 3, keyA: 3 });
-    const values = [
-      { key: 15, keyA: 15 },
-      { key: 1, keyA: 1 },
-      { key: 8, keyA: 8 },
-      { key: 13, keyA: 13 },
-      { key: 16, keyA: 16 },
-      { key: 2, keyA: 2 },
-      { key: 6, keyA: 6 },
-      { key: 9, keyA: 9 },
-      { key: 12, keyA: 12 },
-      { key: 14, keyA: 14 },
-      { key: 4, keyA: 4 },
-      { key: 7, keyA: 7 },
-      { key: 10, keyA: 10 },
-      { key: 5, keyA: 5 }
+    objTreeMultimap.add([11, { key: 11, keyA: 11 }]);
+    objTreeMultimap.add([3, { key: 3, keyA: 3 }]);
+    const values: [number, { key: number; keyA: number }][] = [
+      [15, { key: 15, keyA: 15 }],
+      [1, { key: 1, keyA: 1 }],
+      [8, { key: 8, keyA: 8 }],
+      [13, { key: 13, keyA: 13 }],
+      [16, { key: 16, keyA: 16 }],
+      [2, { key: 2, keyA: 2 }],
+      [6, { key: 6, keyA: 6 }],
+      [9, { key: 9, keyA: 9 }],
+      [12, { key: 12, keyA: 12 }],
+      [14, { key: 14, keyA: 14 }],
+      [4, { key: 4, keyA: 4 }],
+      [7, { key: 7, keyA: 7 }],
+      [10, { key: 10, keyA: 10 }],
+      [5, { key: 5, keyA: 5 }]
     ];
 
     objTreeMultimap.addMany(
-      values.map(item => item.key),
       values
     );
 
     expect(objTreeMultimap.root).toBeInstanceOf(TreeMultimapNode);
 
-    if (objTreeMultimap.root) expect(objTreeMultimap.root.key).toBe(11);
+    if (objTreeMultimap.root) expect(objTreeMultimap.root.key).toBe(6);
 
     expect(objTreeMultimap.count).toBe(16);
 

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;

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', () => {