data-structure-typed 1.52.5 → 1.52.7

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 }]);
   });
 });

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

@@ -86,8 +86,8 @@ describe('Priority Queue Performance Test', () => {
     // for (let i = 0; i < 10000; i++) {
     //   pq.pop();
     // }
-    isDebug && console.log(performance.now() - tS);
-    isDebug && console.log(pq.size);
+    if (isDebug) console.log(performance.now() - tS);
+    if (isDebug) console.log(pq.size);
     const cS = performance.now();
     const cpq = new CPriorityQueue();
 
@@ -98,7 +98,7 @@ describe('Priority Queue Performance Test', () => {
     // for (let i = 0; i < 10000; i++) {
     //   cpq.pop();
     // }
-    isDebug && console.log(performance.now() - cS);
-    isDebug && console.log(cpq.size());
+    if (isDebug) console.log(performance.now() - cS);
+    if (isDebug) console.log(cpq.size());
   });
 });

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

@@ -18,6 +18,12 @@ describe('Stack', () => {
     expect(stack.size).toBe(3);
   });
 
+  it('should has and get', () => {
+    const stack = new Stack<number, { id: number; name: string }>([], { toElementFn: rawElement => rawElement.id });
+    expect(stack.has(1)).toBe(false);
+    expect(stack.size).toBe(0);
+  });
+
   it('should peek at the top element without removing it', () => {
     expect(stack.peek()).toBe(undefined);
     stack.push(1);

package/test/unit/unrestricted-interconversion.test.ts

@@ -48,61 +48,61 @@ const entries: [number, string][] = [
 describe('conversions', () => {
   it('Array to Queue', () => {
     const q = new Queue<number>(orgArr);
-    isDebug && q.print();
+    if (isDebug) q.print();
     expect([...q]).toEqual([6, 1, 2, 7, 5, 3, 4, 9, 8]);
   });
 
   it('Array to Deque', () => {
     const dq = new Deque<number>(orgArr);
-    isDebug && dq.print();
+    if (isDebug) dq.print();
     expect([...dq]).toEqual([6, 1, 2, 7, 5, 3, 4, 9, 8]);
   });
 
   it('Array to SinglyLinkedList', () => {
     const sl = new SinglyLinkedList<number>(orgArr);
-    isDebug && sl.print();
+    if (isDebug) sl.print();
     expect([...sl]).toEqual([6, 1, 2, 7, 5, 3, 4, 9, 8]);
   });
 
   it('Array to DoublyLinkedList', () => {
     const dl = new DoublyLinkedList<number>(orgArr);
-    isDebug && dl.print();
+    if (isDebug) dl.print();
     expect([...dl]).toEqual([6, 1, 2, 7, 5, 3, 4, 9, 8]);
   });
 
   it('Array to Stack', () => {
     const stack = new Stack<number>(orgArr);
-    isDebug && stack.print();
+    if (isDebug) stack.print();
     expect([...stack]).toEqual([6, 1, 2, 7, 5, 3, 4, 9, 8]);
   });
 
   it('Array to MinHeap', () => {
     const minHeap = new MinHeap<number>(orgArr);
-    isDebug && minHeap.print();
+    if (isDebug) minHeap.print();
     expect([...minHeap]).toEqual([1, 5, 2, 7, 6, 3, 4, 9, 8]);
   });
 
   it('Array to MaxHeap', () => {
     const maxHeap = new MaxHeap<number>(orgArr);
-    isDebug && maxHeap.print();
+    if (isDebug) maxHeap.print();
     expect([...maxHeap]).toEqual([9, 8, 4, 7, 5, 2, 3, 1, 6]);
   });
 
   it('Array to MinPriorityQueue', () => {
     const minPQ = new MinPriorityQueue<number>(orgArr);
-    isDebug && minPQ.print();
+    if (isDebug) minPQ.print();
     expect([...minPQ]).toEqual([1, 5, 2, 7, 6, 3, 4, 9, 8]);
   });
 
   it('Array to MaxPriorityQueue', () => {
     const maxPQ = new MaxPriorityQueue<number>(orgArr);
-    isDebug && maxPQ.print();
+    if (isDebug) maxPQ.print();
     expect([...maxPQ]).toEqual([9, 8, 4, 7, 5, 2, 3, 1, 6]);
   });
 
   it('Entry Array to BinaryTree', () => {
     const biTree = new BinaryTree<number>(entries);
-    isDebug && biTree.print();
+    if (isDebug) biTree.print();
     expect([...biTree]).toEqual([
       [9, '9'],
       [7, '7'],
@@ -119,7 +119,7 @@ describe('conversions', () => {
   it('Entry Array to BST', () => {
     const bst = new BST<number>(entries);
     expect(bst.size).toBe(9);
-    isDebug && bst.print();
+    if (isDebug) bst.print();
     expect([...bst]).toEqual([
       [1, '1'],
       [2, '2'],
@@ -136,7 +136,7 @@ describe('conversions', () => {
   it('Entry Array to RedBlackTree', () => {
     const rbTree = new RedBlackTree<number>(entries);
     expect(rbTree.size).toBe(9);
-    isDebug && rbTree.print();
+    if (isDebug) rbTree.print();
     expect([...rbTree]).toEqual([
       [1, '1'],
       [2, '2'],
@@ -153,7 +153,7 @@ describe('conversions', () => {
   it('Entry Array to AVLTree', () => {
     const avl = new AVLTree<number>(entries);
     expect(avl.size).toBe(9);
-    isDebug && avl.print();
+    if (isDebug) avl.print();
     expect([...avl]).toEqual([
       [1, '1'],
       [2, '2'],
@@ -170,7 +170,7 @@ describe('conversions', () => {
   it('Entry Array to TreeMultiMap', () => {
     const treeMulti = new TreeMultiMap<number>(entries);
     expect(treeMulti.size).toBe(9);
-    isDebug && treeMulti.print();
+    if (isDebug) treeMulti.print();
     expect([...treeMulti]).toEqual([
       [1, '1'],
       [2, '2'],
@@ -186,10 +186,10 @@ describe('conversions', () => {
 
   it('HashMap to RedBlackTree', () => {
     const hm = new HashMap(entries);
-    isDebug && hm.print();
+    if (isDebug) hm.print();
     const rbTree = new RedBlackTree<number>(hm);
     expect(rbTree.size).toBe(9);
-    isDebug && rbTree.print();
+    if (isDebug) rbTree.print();
     expect([...rbTree]).toEqual([
       [1, '1'],
       [2, '2'],
@@ -205,10 +205,10 @@ describe('conversions', () => {
 
   it('PriorityQueue to BST', () => {
     const pq = new MinPriorityQueue(orgArr);
-    isDebug && pq.print();
+    if (isDebug) pq.print();
     const bst = new BST<number>(pq);
     expect(bst.size).toBe(9);
-    isDebug && bst.print();
+    if (isDebug) bst.print();
     expect([...bst]).toEqual([
       [1, undefined],
       [2, undefined],
@@ -224,10 +224,10 @@ describe('conversions', () => {
 
   it('Deque to RedBlackTree', () => {
     const dq = new Deque(orgArr);
-    isDebug && dq.print();
+    if (isDebug) dq.print();
     const rbTree = new RedBlackTree<number>(dq);
     expect(rbTree.size).toBe(9);
-    isDebug && rbTree.print();
+    if (isDebug) rbTree.print();
     expect([...rbTree]).toEqual([
       [1, undefined],
       [2, undefined],
@@ -244,12 +244,12 @@ describe('conversions', () => {
   it('Trie to Heap to Deque', () => {
     const trie = new Trie(orgStrArr);
     expect(trie.size).toBe(10);
-    isDebug && trie.print();
+    if (isDebug) trie.print();
     const heap = new Heap<string>(trie, {
       comparator: (a, b) => Number(a) - Number(b)
     });
     expect(heap.size).toBe(10);
-    isDebug && heap.print();
+    if (isDebug) heap.print();
     expect([...heap]).toEqual([
       'transmit',
       'trace',
@@ -264,7 +264,7 @@ describe('conversions', () => {
     ]);
     const dq = new Deque<string>(heap);
     expect(dq.size).toBe(10);
-    isDebug && dq.print();
+    if (isDebug) dq.print();
     expect([...dq]).toEqual([
       'transmit',
       'trace',
@@ -280,7 +280,7 @@ describe('conversions', () => {
     const entries = dq.map((el, i) => <[number, string]>[i, el]);
     const avl = new AVLTree<number, string>(entries);
     expect(avl.size).toBe(10);
-    isDebug && avl.print();
+    if (isDebug) avl.print();
     expect([...avl]).toEqual([
       [0, 'transmit'],
       [1, 'trace'],