data-structure-typed 1.47.5 → 1.47.6

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

@@ -245,7 +245,7 @@ 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 });
+    const treeMultimap = new TreeMultimap([], { iterationType: IterationType.RECURSIVE });
 
     expect(treeMultimap instanceof TreeMultimap);
     treeMultimap.add(11, 11);

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,100 @@
+import {
+  AVLTree,
+  BinaryTree,
+  BST,
+  Deque,
+  DoublyLinkedList,
+  MaxHeap,
+  MaxPriorityQueue,
+  MinHeap,
+  MinPriorityQueue,
+  Queue,
+  RedBlackTree,
+  SinglyLinkedList,
+  Stack,
+  TreeMultimap
+} from '../../src';
+import { isDebugTest } from "../config";
+
+const isDebug = isDebugTest;
+const orgArr: number[] = [6, 1, 2, 7, 5, 3, 4, 9, 8];
+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>(orgArr);
+    expect(bst.size).toBe(9)
+    isDebug && bst.print();
+  })
+
+  it('Entry Array to RedBlackTree', () => {
+    const rbTree = new RedBlackTree<number>(orgArr);
+    expect(rbTree.size).toBe(9)
+    isDebug && rbTree.print();
+  })
+
+  it('Entry Array to AVLTree', () => {
+    const avl = new AVLTree<number>(orgArr);
+    expect(avl.size).toBe(9)
+    isDebug && avl.print();
+  })
+
+  it('Entry Array to TreeMultimap', () => {
+    const treeMulti = new TreeMultimap<number>(orgArr);
+    expect(treeMulti.size).toBe(9)
+    isDebug && treeMulti.print();
+  })
+})
+
+
+