data-structure-typed 1.52.6 → 1.52.8

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

@@ -414,7 +414,7 @@ describe('RedBlackTree 2', () => {
     expect(node225F?.right).toBe(rbTree.NIL);
     expect(node225F?.parent?.key).toBe(155);
     rbTree.add(7);
-    isDebug && rbTree.print();
+    if (isDebug) rbTree.print();
 
     const node15S = rbTree.getNode(15);
     expect(node15S?.left?.key).toBe(10);
@@ -463,7 +463,7 @@ describe('RedBlackTree 2', () => {
     rbTree.add(19);
     rbTree.add(110);
 
-    isDebug && rbTree.print();
+    if (isDebug) rbTree.print();
 
     expect(rbTree.dfs()).toEqual([
       1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 22, 23, 25, 28, 33, 50, 110, 111, 155, 225
@@ -525,19 +525,19 @@ describe('RedBlackTree 2', () => {
     for (let i = 0; i < arr.length; i++) {
       rbTree.add(arr[i]);
     }
-    isDebug && console.log(performance.now() - tS);
+    if (isDebug) console.log(performance.now() - tS);
 
     const cS = performance.now();
 
     for (let i = 0; i < arr.length; i++) {
       competitor.setElement(arr[i], arr[i]);
     }
-    isDebug && console.log(performance.now() - cS);
+    if (isDebug) console.log(performance.now() - cS);
   });
 
   it('duplicates', () => {
     rbTree.addMany([9, 8, 7, 8, 8, 8, 2, 3, 6, 5, 5, 4]);
-    isDebug && rbTree.print();
+    if (isDebug) rbTree.print();
 
     expect(rbTree.size).toBe(8);
     expect(rbTree.isBST()).toBe(true);
@@ -606,7 +606,7 @@ describe('RedBlackTree 2', () => {
       expect(rbTree.getHeight()).toBe(-1);
       expect(nanCount).toBeLessThanOrEqual(inputSize);
 
-      isDebug && rbTree.print();
+      if (isDebug) rbTree.print();
     });
   });
 

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

@@ -1,50 +1,104 @@
-import { SegmentTree } from '../../../../src';
+import { SegmentTree, SegmentTreeNode } from '../../../../src';
 
-describe('SegmentTree', () => {
-  let segmentTree: SegmentTree;
-
-  beforeEach(() => {
-    // Create an example SegmentTree for testing
-    const values = [1, 2, 3, 4, 5];
-    segmentTree = new SegmentTree(values);
+describe('SegmentTreeNode', () => {
+  it('should initialize with correct start, end, sum, and optional value', () => {
+    const node = new SegmentTreeNode(0, 1, 10, 2);
+    expect(node.start).toBe(0);
+    expect(node.end).toBe(1);
+    expect(node.sum).toBe(10);
+    expect(node.value).toBe(2);
   });
 
-  it('should build a valid segment tree', () => {
-    // Check if the root node's sum is correct
-    expect(segmentTree.root?.sum).toBe(15);
+  it('should allow setting start, end, sum, value, left, and right', () => {
+    const node = new SegmentTreeNode(0, 1, 10);
+    node.start = 2;
+    node.end = 3;
+    node.sum = 15;
+    node.value = 2;
+
+    const leftNode = new SegmentTreeNode(0, 1, 5);
+    const rightNode = new SegmentTreeNode(2, 3, 10);
+
+    node.left = leftNode;
+    node.right = rightNode;
+
+    expect(node.start).toBe(2);
+    expect(node.end).toBe(3);
+    expect(node.sum).toBe(15);
+    expect(node.value).toBe(2);
+    expect(node.left).toBe(leftNode);
+    expect(node.right).toBe(rightNode);
   });
+});
 
-  it('should update a node in the segment tree', () => {
-    // Update a node value
-    segmentTree.updateNode(2, 10);
+describe('SegmentTree', () => {
+  it('should initialize with correct values, start, end, and root', () => {
+    const values = [1, 2, 3, 4];
+    const tree = new SegmentTree(values);
 
-    // Check if the sum of the root node is correct after the update
-    expect(segmentTree.root?.sum).toBe(22);
+    expect(tree.values).toEqual(values);
+    expect(tree.start).toBe(0);
+    expect(tree.end).toBe(3);
+    expect(tree.root).toBeDefined();
   });
 
-  it('should query sum by range correctly', () => {
-    // Check if the sum within a specific range is correct
-    expect(segmentTree.querySumByRange(1, 3)).toBe(9); // 2 + 3 + 4 = 9
+  it('should correctly build segment tree with sum of values', () => {
+    const values = [1, 2, 3, 4];
+    const tree = new SegmentTree(values);
+
+    expect(tree.root?.sum).toBe(10); // 1 + 2 + 3 + 4
   });
 
-  it('should handle edge cases for querySumByRange', () => {
-    // Check behavior when the range goes beyond boundaries
-    expect(segmentTree.querySumByRange(0, 4)).toBe(15); // Valid range, should return sum of the specified range
-    expect(segmentTree.querySumByRange(3, 2)).toBe(NaN); // End index is less than start index, should return NaN
-    expect(segmentTree.querySumByRange(0, 10)).toBe(NaN); // Beyond upper bound, should return NaN
+  it('should handle empty values array gracefully', () => {
+    const tree = new SegmentTree([]);
+    expect(tree.values).toEqual([]);
+    expect(tree.root).toBeUndefined();
   });
 
-  it('should handle an empty input array', () => {
-    // Check behavior when dealing with an empty input array
-    const emptySegmentTree = new SegmentTree([]);
-    expect(emptySegmentTree.root).toBe(undefined);
-    expect(emptySegmentTree.querySumByRange(0, 2)).toBe(0); // Sum of an empty array should be 0
+  describe('updateNode', () => {
+    it('should update node value and sum correctly', () => {
+      const values = [1, 2, 3, 4];
+      const tree = new SegmentTree(values);
+      tree.updateNode(1, 5, 2);
+
+      expect(tree.root?.sum).toBe(13); // 1 + 5 + 3 + 4
+      expect(tree.root?.left?.right?.sum).toBe(5);
+      expect(tree.root?.left?.right?.value).toBe(2);
+    });
+
+    it('should do nothing if root is undefined', () => {
+      const tree = new SegmentTree([]);
+      tree.updateNode(0, 10);
+      expect(tree.root).toBeUndefined();
+    });
   });
 
-  it('should handle a single-element input array', () => {
-    // Check behavior when the input array contains a single element
-    const singleElementSegmentTree = new SegmentTree([42]);
-    expect(singleElementSegmentTree.root?.sum).toBe(42);
-    expect(singleElementSegmentTree.querySumByRange(0, 0)).toBe(42); // Range covering the only element should return that element's value
+  describe('querySumByRange', () => {
+    it('should return sum for a given range', () => {
+      const values = [1, 2, 3, 4, 5];
+      const tree = new SegmentTree(values);
+      const result = tree.querySumByRange(1, 3); // 2 + 3 + 4 = 9
+      expect(result).toBe(9);
+    });
+
+    it('should return NaN for an invalid range', () => {
+      const values = [1, 2, 3, 4, 5];
+      const tree = new SegmentTree(values);
+      const result = tree.querySumByRange(3, 1); // Invalid range
+      expect(result).toBeNaN();
+    });
+
+    it('should return 0 if root is undefined', () => {
+      const tree = new SegmentTree([]);
+      const result = tree.querySumByRange(0, 1);
+      expect(result).toBe(0);
+    });
+
+    it('should return NaN if range is out of bounds', () => {
+      const values = [1, 2, 3, 4];
+      const tree = new SegmentTree(values);
+      const result = tree.querySumByRange(-1, 10);
+      expect(result).toBeNaN();
+    });
   });
 });

package/test/unit/data-structures/binary-tree/tree-multi-map.test.ts

@@ -87,7 +87,7 @@ describe('TreeMultiMap operations test1', () => {
     tmm.delete(11);
     expect(tmm.count).toBe(17);
     expect(tmm.getComputedCount()).toBe(17);
-    tmm.delete(3, undefined, true);
+    tmm.delete(3, true);
     expect(tmm.count).toBe(15);
     expect(tmm.getComputedCount()).toBe(15);
   });
@@ -127,19 +127,19 @@ describe('TreeMultiMap operations test1', () => {
     expect(tmm.getComputedCount()).toBe(18);
 
     expect(tmm.has(6));
-    isDebug && tmm.print();
+    if (isDebug) tmm.print();
     expect(tmm.getHeight(6)).toBe(1);
     expect(tmm.getDepth(6)).toBe(3);
     const nodeId10 = tmm.getNode(10);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = tmm.getNode(9, node => node.value);
+    const nodeVal9 = tmm.getNode(node => node.value === 9);
     expect(nodeVal9?.key).toBe(9);
 
-    const nodesByCount1 = tmm.getNodes(1, node => node.count);
+    const nodesByCount1 = tmm.getNodes(node => node.count === 1);
     expect(nodesByCount1.length).toBe(14);
 
-    const nodesByCount2 = tmm.getNodes(2, node => node.count);
+    const nodesByCount2 = tmm.getNodes(node => node.count === 2);
     expect(nodesByCount2.length).toBe(2);
     const leftMost = tmm.getLeftMost();
     expect(leftMost).toBe(1);
@@ -149,7 +149,7 @@ describe('TreeMultiMap operations test1', () => {
     expect(minNodeBySpecificNode?.key).toBe(14);
 
     let subTreeSum = 0;
-    node15 && tmm.dfs(node => (subTreeSum += node.key), 'PRE', 15);
+    if (node15) tmm.dfs(node => (subTreeSum += node.key), 'PRE', 15);
     expect(subTreeSum).toBe(45);
     let lesserSum = 0;
     tmm.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 10);
@@ -180,7 +180,7 @@ describe('TreeMultiMap operations test1', () => {
     expect(bfsNodesAfterBalanced[0].key).toBe(6);
     expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
 
-    const removed11 = tmm.delete(11, undefined, true);
+    const removed11 = tmm.delete(11, true);
     expect(removed11 instanceof Array);
     expect(removed11[0]);
     expect(removed11[0].deleted);
@@ -191,7 +191,7 @@ describe('TreeMultiMap operations test1', () => {
 
     expect(tmm.getHeight(15)).toBe(1);
 
-    const removed1 = tmm.delete(1, undefined, true);
+    const removed1 = tmm.delete(1, true);
     expect(removed1 instanceof Array);
     expect(removed1[0]);
     expect(removed1[0].deleted);
@@ -201,7 +201,7 @@ describe('TreeMultiMap operations test1', () => {
 
     expect(tmm.getHeight()).toBe(5);
 
-    const removed4 = tmm.delete(4, undefined, true);
+    const removed4 = tmm.delete(4, true);
     expect(removed4 instanceof Array);
     expect(removed4[0]);
     expect(removed4[0].deleted);
@@ -210,7 +210,7 @@ describe('TreeMultiMap operations test1', () => {
     expect(tmm.isAVLBalanced()).toBe(false);
     expect(tmm.getHeight()).toBe(5);
 
-    const removed10 = tmm.delete(10, undefined, true);
+    const removed10 = tmm.delete(10, true);
     expect(removed10 instanceof Array);
     expect(removed10[0]);
     expect(removed10[0].deleted);
@@ -219,7 +219,7 @@ describe('TreeMultiMap operations test1', () => {
 
     expect(tmm.getHeight()).toBe(4);
 
-    const removed15 = tmm.delete(15, undefined, true);
+    const removed15 = tmm.delete(15, true);
     expect(removed15 instanceof Array);
     expect(removed15[0]);
     expect(removed15[0].deleted);
@@ -228,7 +228,7 @@ describe('TreeMultiMap operations test1', () => {
     expect(tmm.isAVLBalanced()).toBe(false);
     expect(tmm.getHeight()).toBe(3);
 
-    const removed5 = tmm.delete(5, undefined, true);
+    const removed5 = tmm.delete(5, true);
     expect(removed5 instanceof Array);
     expect(removed5[0]);
     expect(removed5[0].deleted);
@@ -237,7 +237,7 @@ describe('TreeMultiMap operations test1', () => {
     expect(tmm.isAVLBalanced()).toBe(true);
     expect(tmm.getHeight()).toBe(3);
 
-    const removed13 = tmm.delete(13, undefined, true);
+    const removed13 = tmm.delete(13, true);
     expect(removed13 instanceof Array);
     expect(removed13[0]);
     expect(removed13[0].deleted);
@@ -245,7 +245,7 @@ describe('TreeMultiMap operations test1', () => {
     expect(tmm.isAVLBalanced()).toBe(true);
     expect(tmm.getHeight()).toBe(3);
 
-    const removed3 = tmm.delete(3, undefined, true);
+    const removed3 = tmm.delete(3, true);
     expect(removed3 instanceof Array);
     expect(removed3[0]);
     expect(removed3[0].deleted);
@@ -253,7 +253,7 @@ describe('TreeMultiMap operations test1', () => {
     expect(tmm.isAVLBalanced()).toBe(false);
     expect(tmm.getHeight()).toBe(3);
 
-    const removed8 = tmm.delete(8, undefined, true);
+    const removed8 = tmm.delete(8, true);
     expect(removed8 instanceof Array);
     expect(removed8[0]);
     expect(removed8[0].deleted);
@@ -261,17 +261,17 @@ describe('TreeMultiMap operations test1', () => {
     expect(tmm.isAVLBalanced()).toBe(false);
     expect(tmm.getHeight()).toBe(3);
 
-    const removed6 = tmm.delete(6, undefined, true);
+    const removed6 = tmm.delete(6, true);
     expect(removed6 instanceof Array);
     expect(removed6[0]);
     expect(removed6[0].deleted);
     if (removed6[0].deleted) expect(removed6[0].deleted.key).toBe(6);
-    expect(tmm.delete(6, undefined, true).length).toBe(0);
+    expect(tmm.delete(6, true).length).toBe(0);
     expect(tmm.isAVLBalanced()).toBe(false);
 
     expect(tmm.getHeight()).toBe(3);
 
-    const removed7 = tmm.delete(7, undefined, true);
+    const removed7 = tmm.delete(7, true);
     expect(removed7 instanceof Array);
     expect(removed7[0]);
     expect(removed7[0].deleted);
@@ -279,7 +279,7 @@ describe('TreeMultiMap operations test1', () => {
     expect(tmm.isAVLBalanced()).toBe(false);
     expect(tmm.getHeight()).toBe(3);
 
-    const removed9 = tmm.delete(9, undefined, true);
+    const removed9 = tmm.delete(9, true);
     expect(removed9 instanceof Array);
     expect(removed9[0]);
     expect(removed9[0].deleted);
@@ -287,7 +287,7 @@ describe('TreeMultiMap operations test1', () => {
     expect(tmm.isAVLBalanced()).toBe(true);
     expect(tmm.getHeight()).toBe(2);
 
-    const removed14 = tmm.delete(14, undefined, true);
+    const removed14 = tmm.delete(14, true);
     expect(removed14 instanceof Array);
     expect(removed14[0]);
     expect(removed14[0].deleted);
@@ -391,13 +391,13 @@ describe('TreeMultiMap operations test recursively1', () => {
     const nodeId10 = tmm.getNode(10);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = tmm.getNode(9, node => node.value);
+    const nodeVal9 = tmm.getNode(node => node.value === 9);
     expect(nodeVal9?.key).toBe(9);
 
-    const nodesByCount1 = tmm.getNodes(1, node => node.count);
+    const nodesByCount1 = tmm.getNodes(node => node.count === 1);
     expect(nodesByCount1.length).toBe(14);
 
-    const nodesByCount2 = tmm.getNodes(2, node => node.count);
+    const nodesByCount2 = tmm.getNodes(node => node.count === 2);
     expect(nodesByCount2.length).toBe(2);
     const leftMost = tmm.getLeftMost();
     expect(leftMost).toBe(1);
@@ -407,7 +407,7 @@ describe('TreeMultiMap operations test recursively1', () => {
     expect(minNodeBySpecificNode?.key).toBe(14);
 
     let subTreeSum = 0;
-    node15 && tmm.dfs(node => (subTreeSum += node.key), 'PRE', 15);
+    if (node15) tmm.dfs(node => (subTreeSum += node.key), 'PRE', 15);
     expect(subTreeSum).toBe(45);
     let lesserSum = 0;
     expect(tmm.has(9)).toBe(true);
@@ -447,7 +447,7 @@ describe('TreeMultiMap operations test recursively1', () => {
     expect(bfsNodesAfterBalanced[0].key).toBe(6);
     expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
 
-    const removed11 = tmm.delete(11, undefined, true);
+    const removed11 = tmm.delete(11, true);
     expect(removed11 instanceof Array);
     expect(removed11[0]);
     expect(removed11[0].deleted);
@@ -458,7 +458,7 @@ describe('TreeMultiMap operations test recursively1', () => {
 
     expect(tmm.getHeight(15)).toBe(1);
 
-    const removed1 = tmm.delete(1, undefined, true);
+    const removed1 = tmm.delete(1, true);
     expect(removed1 instanceof Array);
     expect(removed1[0]);
     expect(removed1[0].deleted);
@@ -468,7 +468,7 @@ describe('TreeMultiMap operations test recursively1', () => {
 
     expect(tmm.getHeight()).toBe(5);
 
-    const removed4 = tmm.delete(4, undefined, true);
+    const removed4 = tmm.delete(4, true);
     expect(removed4 instanceof Array);
     expect(removed4[0]);
     expect(removed4[0].deleted);
@@ -477,7 +477,7 @@ describe('TreeMultiMap operations test recursively1', () => {
     expect(tmm.isAVLBalanced()).toBe(false);
     expect(tmm.getHeight()).toBe(5);
 
-    const removed10 = tmm.delete(10, undefined, true);
+    const removed10 = tmm.delete(10, true);
     expect(removed10 instanceof Array);
     expect(removed10[0]);
     expect(removed10[0].deleted);
@@ -486,7 +486,7 @@ describe('TreeMultiMap operations test recursively1', () => {
 
     expect(tmm.getHeight()).toBe(4);
 
-    const removed15 = tmm.delete(15, undefined, true);
+    const removed15 = tmm.delete(15, true);
     expect(removed15 instanceof Array);
     expect(removed15[0]);
     expect(removed15[0].deleted);
@@ -495,7 +495,7 @@ describe('TreeMultiMap operations test recursively1', () => {
     expect(tmm.isAVLBalanced()).toBe(false);
     expect(tmm.getHeight()).toBe(3);
 
-    const removed5 = tmm.delete(5, undefined, true);
+    const removed5 = tmm.delete(5, true);
     expect(removed5 instanceof Array);
     expect(removed5[0]);
     expect(removed5[0].deleted);
@@ -504,7 +504,7 @@ describe('TreeMultiMap operations test recursively1', () => {
     expect(tmm.isAVLBalanced()).toBe(true);
     expect(tmm.getHeight()).toBe(3);
 
-    const removed13 = tmm.delete(13, undefined, true);
+    const removed13 = tmm.delete(13, true);
     expect(removed13 instanceof Array);
     expect(removed13[0]);
     expect(removed13[0].deleted);
@@ -512,7 +512,7 @@ describe('TreeMultiMap operations test recursively1', () => {
     expect(tmm.isAVLBalanced()).toBe(true);
     expect(tmm.getHeight()).toBe(3);
 
-    const removed3 = tmm.delete(3, undefined, true);
+    const removed3 = tmm.delete(3, true);
     expect(removed3 instanceof Array);
     expect(removed3[0]);
     expect(removed3[0].deleted);
@@ -520,7 +520,7 @@ describe('TreeMultiMap operations test recursively1', () => {
     expect(tmm.isAVLBalanced()).toBe(false);
     expect(tmm.getHeight()).toBe(3);
 
-    const removed8 = tmm.delete(8, undefined, true);
+    const removed8 = tmm.delete(8, true);
     expect(removed8 instanceof Array);
     expect(removed8[0]);
     expect(removed8[0].deleted);
@@ -528,17 +528,17 @@ describe('TreeMultiMap operations test recursively1', () => {
     expect(tmm.isAVLBalanced()).toBe(false);
     expect(tmm.getHeight()).toBe(3);
 
-    const removed6 = tmm.delete(6, undefined, true);
+    const removed6 = tmm.delete(6, true);
     expect(removed6 instanceof Array);
     expect(removed6[0]);
     expect(removed6[0].deleted);
     if (removed6[0].deleted) expect(removed6[0].deleted.key).toBe(6);
-    expect(tmm.delete(6, undefined, true).length).toBe(0);
+    expect(tmm.delete(6, true).length).toBe(0);
     expect(tmm.isAVLBalanced()).toBe(false);
 
     expect(tmm.getHeight()).toBe(3);
 
-    const removed7 = tmm.delete(7, undefined, true);
+    const removed7 = tmm.delete(7, true);
     expect(removed7 instanceof Array);
     expect(removed7[0]);
     expect(removed7[0].deleted);
@@ -546,7 +546,7 @@ describe('TreeMultiMap operations test recursively1', () => {
     expect(tmm.isAVLBalanced()).toBe(false);
     expect(tmm.getHeight()).toBe(3);
 
-    const removed9 = tmm.delete(9, undefined, true);
+    const removed9 = tmm.delete(9, true);
     expect(removed9 instanceof Array);
     expect(removed9[0]);
     expect(removed9[0].deleted);
@@ -554,7 +554,7 @@ describe('TreeMultiMap operations test recursively1', () => {
     expect(tmm.isAVLBalanced()).toBe(true);
     expect(tmm.getHeight()).toBe(2);
 
-    const removed14 = tmm.delete(14, undefined, true);
+    const removed14 = tmm.delete(14, true);
     expect(removed14 instanceof Array);
     expect(removed14[0]);
     expect(removed14[0].deleted);
@@ -626,7 +626,7 @@ describe('TreeMultiMap delete test', function () {
   it(`Observe the time consumption of TreeMultiMap.dfs be good`, function () {
     const startDFS = performance.now();
     const dfs = tmm.dfs(node => node);
-    isDebug && console.log('---bfs', performance.now() - startDFS, dfs.length);
+    if (isDebug) console.log('---bfs', performance.now() - startDFS, dfs.length);
   });
 
   it('The structure remains normal after random deletion', function () {
@@ -664,7 +664,7 @@ describe('TreeMultiMap delete test', function () {
     }
 
     for (let i = 0; i < inputSize; i++) {
-      tmm.delete(i, undefined, true);
+      tmm.delete(i, true);
     }
 
     let nilCount = 0;
@@ -679,7 +679,7 @@ describe('TreeMultiMap delete test', function () {
     expect(tmm.getHeight()).toBe(-1);
     expect(nilCount).toBe(tmm.size + 1);
 
-    isDebug && tmm.print();
+    if (isDebug) tmm.print();
   });
 
   it(`Random additions, count deletions of structures are normal`, function () {
@@ -705,7 +705,7 @@ describe('TreeMultiMap delete test', function () {
     expect(tmm.getHeight()).toBeGreaterThanOrEqual(0);
     expect(nanCount).toBeLessThanOrEqual(inputSize);
 
-    isDebug && tmm.print();
+    if (isDebug) tmm.print();
   });
 
   it('should the clone method', () => {

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

@@ -45,7 +45,7 @@ class MyGraph<
   }
 
   degreeOf(vertexOrKey: VO | VertexKey): number {
-    return 1 ?? Number(vertexOrKey);
+    return Number(vertexOrKey);
   }
 
   edgeSet(): EO[] {

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

@@ -209,8 +209,8 @@ describe('Inherit from DirectedGraph and perform operations', () => {
 
     expect(removedEdge).toBeInstanceOf(MyEdge);
     if (removedEdge) {
-      removedEdge && expect(removedEdge.value).toBe('edge-data1-2');
-      removedEdge && expect(removedEdge.src).toBe(1);
+      if (removedEdge) expect(removedEdge.value).toBe('edge-data1-2');
+      if (removedEdge) expect(removedEdge.src).toBe(1);
     }
     expect(edgeAfterRemoval).toBe(undefined);
   });
@@ -241,8 +241,8 @@ describe('Inherit from DirectedGraph and perform operations', () => {
     if (sorted && sorted.length > 0) {
       expect(sorted.length).toBe(9);
       if (sorted[0] instanceof MyVertex) expect(sorted[0].data).toBe('data9');
-      sorted[3] instanceof MyVertex && expect(sorted[3].data).toBe('data6');
-      sorted[8] instanceof MyVertex && expect(sorted[8].key).toBe(1);
+      if (sorted[3] instanceof MyVertex) expect(sorted[3].data).toBe('data6');
+      if (sorted[8] instanceof MyVertex) expect(sorted[8].key).toBe(1);
     }
   });
 

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

@@ -18,14 +18,19 @@ describe('UndirectedGraph Operation Test', () => {
   });
 
   it('should add vertices', () => {
+    expect(graph.isEmpty()).toBe(true);
     const vertex1 = new UndirectedVertex('A');
     const vertex2 = new UndirectedVertex('B');
 
     graph.addVertex(vertex1);
+    expect(graph.isEmpty()).toBe(false);
     graph.addVertex(vertex2);
 
     expect(graph.hasVertex(vertex1)).toBe(true);
     expect(graph.hasVertex(vertex2)).toBe(true);
+    expect(graph.isEmpty()).toBe(false);
+    graph.clear();
+    expect(graph.isEmpty()).toBe(true);
   });
 
   it('should add edges', () => {
@@ -39,6 +44,8 @@ describe('UndirectedGraph Operation Test', () => {
 
     expect(graph.hasEdge('A', 'B')).toBe(true);
     expect(graph.hasEdge('B', 'A')).toBe(true);
+    expect(graph.has('A')).toBe(true);
+    expect(graph.get('A')).toBe(undefined);
   });
 
   it('should delete edges', () => {
@@ -577,7 +584,7 @@ describe('UndirectedGraph tarjan', () => {
     const graph = createExampleGraph5();
     const cycles = graph.getCycles();
     expect(cycles.length).toBe(13);
-    expect(cycles).toEqual([
+    const expectedCycles = [
       ['A', 'B', 'C', 'D', 'I', 'H', 'F', 'E'],
       ['A', 'B', 'C', 'D', 'I', 'H', 'F', 'G', 'E'],
       ['A', 'B', 'C', 'H', 'F', 'E'],
@@ -591,7 +598,12 @@ describe('UndirectedGraph tarjan', () => {
       ['C', 'D', 'I', 'H'],
       ['E', 'F', 'G'],
       ['H', 'J', 'K']
-    ]);
+    ];
+    expect(cycles).toEqual(expectedCycles);
+    const cloned = graph.clone();
+    const clonedCycles = cloned.getCycles();
+    expect(clonedCycles.length).toBe(13);
+    expect(clonedCycles).toEqual(expectedCycles);
   });
 
   // it('should uncuttable graph tarjan SCCs return correct result', () => {

package/test/unit/data-structures/hash/hash-map.test.ts

@@ -303,7 +303,7 @@ describe('HashMap', () => {
     });
 
     it('print', () => {
-      expect(hm.print()).toEqual([
+      expect(hm.toVisual()).toEqual([
         [2, 2],
         [3, 3],
         [4, 4],

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

@@ -65,7 +65,7 @@ describe('DoublyLinkedList Operation Test', () => {
     dList.delete('5');
     expect([...dList]).toEqual(['1', '6', '0', '9']);
     expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
-    expect(cloned.print()).toEqual(['1', '6', '0', '5', '9']);
+    expect(cloned.toVisual()).toEqual(['1', '6', '0', '5', '9']);
   });
 
   it('should find undefined', () => {

package/test/unit/data-structures/matrix/navigator.test.ts

@@ -176,7 +176,7 @@ describe('Navigator', () => {
     navigator.start();
 
     // The character should not move
-    isDebug && console.log(visitedCells);
+    if (isDebug) console.log(visitedCells);
     expect(visitedCells).toEqual([
       [0, 1],
       [1, 1],
@@ -226,7 +226,7 @@ describe('Navigator', () => {
     navigator.start();
 
     // The character should have navigated the grid, handled turns, and edge cases
-    isDebug && console.log(visitedCells);
+    if (isDebug) console.log(visitedCells);
     expect(visitedCells).toEqual([
       [0, 1],
       [0, 2],

package/test/unit/data-structures/priority-queue/min-priority-queue.test.ts

@@ -76,6 +76,6 @@ describe('MinPriorityQueue Operation Test', () => {
     );
     expect(mapped instanceof MinPriorityQueue).toBe(true);
     expect([...mapped]).toEqual([{ key: 1 }, { key: 5 }, { key: 7 }]);
-    expect(mapped.print()).toEqual([{ key: 1 }, { key: 5 }, { key: 7 }]);
+    expect(mapped.toVisual()).toEqual([{ key: 1 }, { key: 5 }, { key: 7 }]);
   });
 });