data-structure-typed 1.47.5 → 1.47.7

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/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/heap/heap.test.ts

@@ -23,7 +23,7 @@ describe('Heap Operation Test', () => {
   });
 
   it('should object heap work well', function () {
-    const minHeap = new MinHeap<{ a: string; key: number }>({ comparator: (a, b) => a.key - b.key });
+    const minHeap = new MinHeap<{ a: string; key: number }>([], { comparator: (a, b) => a.key - b.key });
     minHeap.add({ key: 1, a: 'a1' });
     minHeap.add({ key: 6, a: 'a6' });
     minHeap.add({ key: 2, a: 'a2' });
@@ -43,7 +43,7 @@ describe('Heap Operation Test', () => {
       i++;
     }
 
-    const maxHeap = new MaxHeap<{ key: number; a: string }>({ comparator: (a, b) => b.key - a.key });
+    const maxHeap = new MaxHeap<{ key: number; a: string }>([], { comparator: (a, b) => b.key - a.key });
     maxHeap.add({ key: 1, a: 'a1' });
     maxHeap.add({ key: 6, a: 'a6' });
     maxHeap.add({ key: 5, a: 'a5' });

package/test/unit/data-structures/heap/max-heap.test.ts

@@ -5,7 +5,7 @@ describe('MaxHeap', () => {
   let maxHeap: MaxHeap<number>;
 
   beforeEach(() => {
-    maxHeap = new MaxHeap({ comparator: numberComparator });
+    maxHeap = new MaxHeap([], { comparator: numberComparator });
   });
 
   it('add and poll elements in descending order', () => {

package/test/unit/data-structures/heap/min-heap.test.ts

@@ -5,7 +5,7 @@ describe('MinHeap', () => {
   let minHeap: MinHeap<number>;
 
   beforeEach(() => {
-    minHeap = new MinHeap({ comparator: numberComparator });
+    minHeap = new MinHeap([], { comparator: numberComparator });
   });
 
   it('add and poll elements in ascending order', () => {

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

@@ -16,7 +16,7 @@ describe('MaxPriorityQueue Operation Test', () => {
   });
 
   it('should add elements and maintain heap property in a object MaxPriorityQueue', () => {
-    const priorityQueue = new MaxPriorityQueue<{ keyA: number }>({ comparator: (a, b) => b.keyA - a.keyA });
+    const priorityQueue = new MaxPriorityQueue<{ keyA: number }>([], { comparator: (a, b) => b.keyA - a.keyA });
     priorityQueue.refill([{ keyA: 5 }, { keyA: 3 }, { keyA: 1 }]);
     priorityQueue.add({ keyA: 7 });
 
@@ -52,7 +52,7 @@ describe('MaxPriorityQueue Operation Test', () => {
 
   it('should correctly heapify an array', () => {
     const array = [5, 3, 7, 1];
-    const heap = MaxPriorityQueue.heapify<number>({ elements: array, comparator: (a, b) => b - a });
+    const heap = MaxPriorityQueue.heapify<number>(array, { comparator: (a, b) => b - a });
     heap.refill(array);
 
     expect(heap.poll()).toBe(7);
@@ -63,7 +63,8 @@ describe('MaxPriorityQueue Operation Test', () => {
 
   it('should correctly heapify an object array', () => {
     const elements = [{ keyA: 5 }, { keyA: 3 }, { keyA: 7 }, { keyA: 1 }];
-    const maxPQ = MaxPriorityQueue.heapify<{ keyA: number }>({ elements, comparator: (a, b) => b.keyA - a.keyA });
+    debugger
+    const maxPQ = MaxPriorityQueue.heapify<{ keyA: number }>(elements, { comparator: (a, b) => b.keyA - a.keyA });
 
     expect(maxPQ.poll()?.keyA).toBe(7);
     expect(maxPQ.poll()?.keyA).toBe(5);

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

@@ -5,7 +5,7 @@ import { isDebugTest } from '../../../config';
 const isDebug = isDebugTest;
 describe('PriorityQueue Operation Test', () => {
   it('should PriorityQueue poll, pee, heapify, toArray work well', function () {
-    const minPQ = new PriorityQueue<number>({ comparator: (a, b) => a - b });
+    const minPQ = new PriorityQueue<number>([], { comparator: (a, b) => a - b });
     minPQ.refill([5, 2, 3, 4, 6, 1]);
     expect(minPQ.toArray()).toEqual([1, 2, 3, 4, 6, 5]);
     minPQ.poll();
@@ -14,15 +14,14 @@ describe('PriorityQueue Operation Test', () => {
     expect(minPQ.toArray()).toEqual([4, 5, 6]);
     expect(minPQ.peek()).toBe(4);
     expect(
-      PriorityQueue.heapify({
-        elements: [3, 2, 1, 5, 6, 7, 8, 9, 10],
+      PriorityQueue.heapify([3, 2, 1, 5, 6, 7, 8, 9, 10], {
         comparator: (a, b) => a - b
       }).toArray()
-    ).toEqual([1, 2, 3, 5, 6, 7, 8, 9, 10]);
+    ).toEqual([1, 3, 2, 5, 6, 7, 8, 9, 10]);
   });
 
   it('should Max PriorityQueue poll, peek, heapify, toArray work well', function () {
-    const maxPriorityQueue = new PriorityQueue<number>({ comparator: (a, b) => b - a });
+    const maxPriorityQueue = new PriorityQueue<number>([], { comparator: (a, b) => b - a });
     maxPriorityQueue.refill([5, 2, 3, 4, 6, 1]);
     expect(maxPriorityQueue.toArray()).toEqual([6, 5, 3, 4, 2, 1]);
     maxPriorityQueue.poll();
@@ -31,15 +30,15 @@ describe('PriorityQueue Operation Test', () => {
     expect(maxPriorityQueue.toArray()).toEqual([3, 2, 1]);
     expect(maxPriorityQueue.peek()).toBe(3);
     expect(
-      PriorityQueue.heapify({
-        elements: [3, 2, 1, 5, 6, 7, 8, 9, 10],
+      PriorityQueue.heapify([3, 2, 1, 5, 6, 7, 8, 9, 10], {
+
         comparator: (a, b) => a - b
       }).toArray()
-    ).toEqual([1, 2, 3, 5, 6, 7, 8, 9, 10]);
+    ).toEqual([1, 3, 2, 5, 6, 7, 8, 9, 10]);
   });
 
   it('should PriorityQueue clone, sort, getNodes, dfs work well', function () {
-    const minPQ1 = new PriorityQueue<number>({ comparator: (a, b) => a - b });
+    const minPQ1 = new PriorityQueue<number>([], { comparator: (a, b) => a - b });
     minPQ1.refill([2, 5, 8, 3, 1, 6, 7, 4]);
     const clonedPriorityQueue = minPQ1.clone();
     expect(clonedPriorityQueue.elements).toEqual(minPQ1.elements);
@@ -52,7 +51,7 @@ describe('PriorityQueue Operation Test', () => {
 
 describe('Priority Queue Performance Test', () => {
   it('should numeric heap work well', function () {
-    const pq = new PriorityQueue({ comparator: (a, b) => b - a });
+    const pq = new PriorityQueue<number>([], { comparator: (a, b) => b - a });
 
     const tS = performance.now();
 

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

@@ -83,7 +83,7 @@ describe('Stack iterative methods', () => {
       result.push(element);
     }
 
-    expect(result).toEqual([3, 2, 1]); // iteration should start from the top of the stack
+    expect(result).toEqual([1, 2, 3]); // iteration should start from the top of the stack
   });
 
   test('should apply forEach to the stack', () => {
@@ -92,7 +92,7 @@ describe('Stack iterative methods', () => {
       result.push(element);
     });
 
-    expect(result).toEqual([3, 2, 1]);
+    expect(result).toEqual([1, 2, 3]);
   });
 
   test('should filter elements in the stack', () => {

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

@@ -0,0 +1,156 @@
+import {
+  AVLTree,
+  BinaryTree,
+  BST,
+  Deque,
+  DoublyLinkedList,
+  HashMap,
+  Heap,
+  MaxHeap,
+  MaxPriorityQueue,
+  MinHeap,
+  MinPriorityQueue,
+  Queue,
+  RedBlackTree,
+  SinglyLinkedList,
+  Stack,
+  TreeMultimap,
+  Trie
+} from '../../src';
+import { isDebugTest } from "../config";
+
+const isDebug = isDebugTest;
+const orgArr: number[] = [6, 1, 2, 7, 5, 3, 4, 9, 8];
+const orgStrArr: string[] = [
+  "trie",
+  "trial",
+  "trick",
+  "trip",
+  "tree",
+  "trend",
+  "triangle",
+  "track",
+  "trace",
+  "transmit"
+];
+const entries: [number, number][] = [[6, 6], [1, 1], [2, 2], [7, 7], [5, 5], [3, 3], [4, 4], [9, 9], [8, 8]];
+
+describe('conversions', () => {
+  it('Array to Queue', () => {
+    const q = new Queue<number>(orgArr);
+    isDebug && q.print();
+  })
+
+  it('Array to Deque', () => {
+    const dq = new Deque<number>(orgArr);
+    isDebug && dq.print();
+  })
+
+  it('Array to SinglyLinkedList', () => {
+    const sl = new SinglyLinkedList<number>(orgArr);
+    isDebug && sl.print();
+  })
+
+  it('Array to DoublyLinkedList', () => {
+    const dl = new DoublyLinkedList<number>(orgArr);
+    isDebug && dl.print();
+  })
+
+  it('Array to Stack', () => {
+    const stack = new Stack<number>(orgArr);
+    isDebug && stack.print();
+  })
+
+  it('Array to MinHeap', () => {
+    const minHeap = new MinHeap<number>(orgArr);
+    isDebug && minHeap.print();
+  })
+
+  it('Array to MaxHeap', () => {
+    const maxHeap = new MaxHeap<number>(orgArr);
+    isDebug && maxHeap.print();
+  })
+
+  it('Array to MinPriorityQueue', () => {
+    const minPQ = new MinPriorityQueue<number>(orgArr);
+    isDebug && minPQ.print();
+  })
+
+  it('Array to MaxPriorityQueue', () => {
+    const maxPQ = new MaxPriorityQueue<number>(orgArr);
+    isDebug && maxPQ.print();
+  })
+
+  it('Entry Array to BinaryTree', () => {
+    const biTree = new BinaryTree<number>(entries);
+    isDebug && biTree.print();
+  })
+
+  it('Entry Array to BST', () => {
+    const bst = new BST<number>(entries);
+    expect(bst.size).toBe(9)
+    isDebug && bst.print();
+  })
+
+  it('Entry Array to RedBlackTree', () => {
+    const rbTree = new RedBlackTree<number>(entries);
+    expect(rbTree.size).toBe(9)
+    isDebug && rbTree.print();
+  })
+
+  it('Entry Array to AVLTree', () => {
+    const avl = new AVLTree<number>(entries);
+    expect(avl.size).toBe(9)
+    isDebug && avl.print();
+  })
+
+  it('Entry Array to TreeMultimap', () => {
+    const treeMulti = new TreeMultimap<number>(entries);
+    expect(treeMulti.size).toBe(9)
+    isDebug && treeMulti.print();
+  })
+
+  it('HashMap to RedBlackTree', () => {
+    const hm = new HashMap(entries);
+    isDebug && hm.print()
+    const rbTree = new RedBlackTree<number>(hm);
+    expect(rbTree.size).toBe(9)
+    isDebug && rbTree.print();
+  })
+
+  it('PriorityQueue to BST', () => {
+    const pq = new MinPriorityQueue(orgArr);
+    isDebug && pq.print();
+    const bst = new BST<number>(pq);
+    expect(bst.size).toBe(9)
+    isDebug && bst.print();
+  })
+
+  it('Deque to RedBlackTree', () => {
+    const dq = new Deque(orgArr);
+    isDebug && dq.print();
+    const rbTree = new RedBlackTree<number>(dq);
+    expect(rbTree.size).toBe(9)
+    isDebug && rbTree.print();
+  })
+
+  it('Trie to Heap to Deque', () => {
+    const trie = new Trie(orgStrArr);
+    expect(trie.size).toBe(10);
+    isDebug && trie.print();
+    const heap = new Heap<string>(trie, { comparator: (a, b) => Number(a) - Number(b) });
+    expect(heap.size).toBe(10);
+    isDebug && heap.print();
+    const dq = new Deque<string>(heap);
+    expect(dq.size).toBe(10);
+    isDebug && dq.print();
+    const entries = dq.map((el, i) => <[number, string]>[i, el]);
+    const avl = new AVLTree<string>(entries);
+    expect(avl.size).toBe(10)
+    isDebug && avl.print();
+  })
+
+})
+
+
+

package/tsconfig-cjs.json

@@ -6,7 +6,7 @@
     "module": "CommonJS",
     "target": "ES2015",
     "moduleResolution": "node",
-    "sourceMap": true,
+    "sourceMap": true
   },
   "include": [
     "./src/**/*.ts"