data-structure-typed 1.44.0 → 1.45.0

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

@@ -22,7 +22,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'});
@@ -37,7 +37,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'});
@@ -62,13 +62,13 @@ describe('FibonacciHeap', () => {
     heap = new FibonacciHeap<number>();
   });
 
-  test('push & peek', () => {
+  it('push & peek', () => {
     heap.push(10);
     heap.push(5);
     expect(heap.peek()).toBe(5);
   });
 
-  test('pop', () => {
+  it('pop', () => {
     heap.push(10);
     heap.push(5);
     heap.push(15);
@@ -77,11 +77,11 @@ describe('FibonacciHeap', () => {
     expect(heap.pop()).toBe(15);
   });
 
-  test('pop on an empty heap', () => {
+  it('pop on an empty heap', () => {
     expect(heap.pop()).toBeUndefined();
   });
 
-  test('size', () => {
+  it('size', () => {
     expect(heap.size).toBe(0);
     heap.push(10);
     expect(heap.size).toBe(1);
@@ -89,7 +89,7 @@ describe('FibonacciHeap', () => {
     expect(heap.size).toBe(0);
   });
 
-  test('clear', () => {
+  it('clear', () => {
     heap.push(10);
     heap.push(5);
     heap.clear();
@@ -97,7 +97,7 @@ describe('FibonacciHeap', () => {
     expect(heap.peek()).toBeUndefined();
   });
 
-  test('custom comparator', () => {
+  it('custom comparator', () => {
     const maxHeap = new FibonacciHeap<number>((a, b) => b - a);
     maxHeap.push(10);
     maxHeap.push(5);

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

@@ -8,7 +8,7 @@ describe('MaxHeap', () => {
     maxHeap = new MaxHeap({comparator: numberComparator});
   });
 
-  test('add and poll elements in descending order', () => {
+  it('add and poll elements in descending order', () => {
     maxHeap.add(3);
     maxHeap.add(1);
     maxHeap.add(4);
@@ -20,7 +20,7 @@ describe('MaxHeap', () => {
     expect(maxHeap.poll()).toBe(1);
   });
 
-  test('peek at the top element without removing it', () => {
+  it('peek at the top element without removing it', () => {
     maxHeap.add(3);
     maxHeap.add(1);
     maxHeap.add(4);
@@ -30,7 +30,7 @@ describe('MaxHeap', () => {
     expect(maxHeap.size).toBe(4);
   });
 
-  test('sort elements in descending order', () => {
+  it('sort elements in descending order', () => {
     maxHeap.add(3);
     maxHeap.add(1);
     maxHeap.add(4);
@@ -40,7 +40,7 @@ describe('MaxHeap', () => {
     expect(sortedArray).toEqual([4, 3, 2, 1]);
   });
 
-  test('check if the heap is empty', () => {
+  it('check if the heap is empty', () => {
     expect(maxHeap.isEmpty()).toBe(true);
 
     maxHeap.add(5);

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

@@ -8,7 +8,7 @@ describe('MinHeap', () => {
     minHeap = new MinHeap({comparator: numberComparator});
   });
 
-  test('add and poll elements in ascending order', () => {
+  it('add and poll elements in ascending order', () => {
     minHeap.add(3);
     minHeap.add(1);
     minHeap.add(4);
@@ -20,7 +20,7 @@ describe('MinHeap', () => {
     expect(minHeap.poll()).toBe(4);
   });
 
-  test('peek at the top element without removing it', () => {
+  it('peek at the top element without removing it', () => {
     minHeap.add(3);
     minHeap.add(1);
     minHeap.add(4);
@@ -30,7 +30,7 @@ describe('MinHeap', () => {
     expect(minHeap.size).toBe(4);
   });
 
-  test('sort elements in ascending order', () => {
+  it('sort elements in ascending order', () => {
     minHeap.add(3);
     minHeap.add(1);
     minHeap.add(4);
@@ -40,7 +40,7 @@ describe('MinHeap', () => {
     expect(sortedArray).toEqual([1, 2, 3, 4]);
   });
 
-  test('check if the heap is empty', () => {
+  it('check if the heap is empty', () => {
     expect(minHeap.isEmpty()).toBe(true);
 
     minHeap.add(5);

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

@@ -60,7 +60,7 @@ describe('DoublyLinkedList Operation Test', () => {
 
 describe('DoublyLinkedList Operation Test', () => {
   let list: DoublyLinkedList<number>;
-  let objectList: DoublyLinkedList<{keyA: number}>;
+  let objectList: DoublyLinkedList<{ keyA: number }>;
 
   beforeEach(() => {
     list = new DoublyLinkedList();

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

@@ -11,10 +11,10 @@ describe('SinglyLinkedListNode', () => {
 
 describe('SinglyLinkedList Operation Test', () => {
   let list: SinglyLinkedList<number>;
-  let objectList: SinglyLinkedList<{keyA: number}>;
+  let objectList: SinglyLinkedList<{ keyA: number }>;
   beforeEach(() => {
     list = new SinglyLinkedList<number>();
-    objectList = new SinglyLinkedList<{keyA: number}>();
+    objectList = new SinglyLinkedList<{ keyA: number }>();
   });
 
   describe('push', () => {

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

@@ -65,21 +65,21 @@ describe('SkipList', () => {
     skipList.add(4, 'Four');
   });
 
-  test('getFirst() should return the getFirst element', () => {
+  it('getFirst() should return the getFirst element', () => {
     expect(skipList.getFirst()).toBe('One');
   });
 
-  test('getLast() should return the getLast element', () => {
+  it('getLast() should return the getLast element', () => {
     expect(skipList.getLast()).toBe('Four');
   });
 
-  test('higher(key) should return the getFirst element greater than the given key', () => {
+  it('higher(key) should return the getFirst element greater than the given key', () => {
     expect(skipList.higher(2)).toBe('Three');
     expect(skipList.higher(3)).toBe('Four');
     expect(skipList.higher(4)).toBeUndefined();
   });
 
-  test('lower(key) should return the getLast element less than the given key', () => {
+  it('lower(key) should return the getLast element less than the given key', () => {
     expect(skipList.lower(2)).toBe('One');
     expect(skipList.lower(1)).toBe(null);
   });

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});
 
@@ -63,7 +63,7 @@ describe('MaxPriorityQueue Operation Test', () => {
 
   it('should correctly heapify an object array', () => {
     const nodes = [{keyA: 5}, {keyA: 3}, {keyA: 7}, {keyA: 1}];
-    const maxPQ = MaxPriorityQueue.heapify<{keyA: number}>({nodes: nodes, comparator: (a, b) => b.keyA - a.keyA});
+    const maxPQ = MaxPriorityQueue.heapify<{ keyA: number }>({nodes: nodes, 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

@@ -13,7 +13,10 @@ describe('PriorityQueue Operation Test', () => {
     minPQ.poll();
     expect(minPQ.toArray()).toEqual([4, 5, 6]);
     expect(minPQ.peek()).toBe(4);
-    expect(PriorityQueue.heapify({nodes: [3, 2, 1, 5, 6, 7, 8, 9, 10], comparator: (a, b) => a - b}).toArray()).toEqual([
+    expect(PriorityQueue.heapify({
+      nodes: [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
     ]);
   });
@@ -27,7 +30,10 @@ describe('PriorityQueue Operation Test', () => {
     maxPriorityQueue.poll();
     expect(maxPriorityQueue.toArray()).toEqual([3, 2, 1]);
     expect(maxPriorityQueue.peek()).toBe(3);
-    expect(PriorityQueue.heapify({nodes: [3, 2, 1, 5, 6, 7, 8, 9, 10], comparator: (a, b) => a - b}).toArray()).toEqual([
+    expect(PriorityQueue.heapify({
+      nodes: [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
     ]);
   });

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

@@ -155,12 +155,12 @@ describe('Deque', () => {
     deque = new Deque<number>();
   });
 
-  test('should initialize an empty deque', () => {
+  it('should initialize an empty deque', () => {
     expect(deque.size).toBe(0);
     expect(deque.isEmpty()).toBe(true);
   });
 
-  test('should add elements to the front and back', () => {
+  it('should add elements to the front and back', () => {
     deque.addFirst(1);
     deque.addLast(2);
 
@@ -169,7 +169,7 @@ describe('Deque', () => {
     expect(deque.getLast()).toBe(2);
   });
 
-  test('should remove elements from the front and back', () => {
+  it('should remove elements from the front and back', () => {
     deque.addFirst(1);
     deque.addLast(2);
 
@@ -181,7 +181,7 @@ describe('Deque', () => {
     expect(lastElement).toBe(2);
   });
 
-  test('should get elements by index', () => {
+  it('should get elements by index', () => {
     deque.addLast(1);
     deque.addLast(2);
     deque.addLast(3);
@@ -191,13 +191,13 @@ describe('Deque', () => {
     expect(deque.getAt(2)).toBe(3);
   });
 
-  test('should return null for out-of-bounds index', () => {
+  it('should return null for out-of-bounds index', () => {
     expect(deque.getAt(0)).toBe(undefined);
     expect(deque.getAt(1)).toBe(undefined);
     expect(deque.getAt(-1)).toBe(undefined);
   });
 
-  test('should check if the deque is empty', () => {
+  it('should check if the deque is empty', () => {
     expect(deque.isEmpty()).toBe(true);
 
     deque.addLast(1);
@@ -215,12 +215,12 @@ describe('ArrayDeque', () => {
     deque = new ArrayDeque<number>();
   });
 
-  test('should initialize an empty deque', () => {
+  it('should initialize an empty deque', () => {
     expect(deque.size).toBe(0);
     expect(deque.isEmpty()).toBe(true);
   });
 
-  test('should add elements to the front and back', () => {
+  it('should add elements to the front and back', () => {
     deque.addFirst(1);
     deque.addLast(2);
 
@@ -229,7 +229,7 @@ describe('ArrayDeque', () => {
     expect(deque.getLast()).toBe(2);
   });
 
-  test('should remove elements from the front and back', () => {
+  it('should remove elements from the front and back', () => {
     deque.addFirst(1);
     deque.addLast(2);
 
@@ -241,7 +241,7 @@ describe('ArrayDeque', () => {
     expect(lastElement).toBe(2);
   });
 
-  test('should get elements by index', () => {
+  it('should get elements by index', () => {
     deque.addLast(1);
     deque.addLast(2);
     deque.addLast(3);
@@ -251,13 +251,13 @@ describe('ArrayDeque', () => {
     expect(deque.get(2)).toBe(3);
   });
 
-  test('should return null for out-of-bounds index', () => {
+  it('should return null for out-of-bounds index', () => {
     expect(deque.get(0)).toBe(null);
     expect(deque.get(1)).toBe(null);
     expect(deque.get(-1)).toBe(null);
   });
 
-  test('should check if the deque is empty', () => {
+  it('should check if the deque is empty', () => {
     expect(deque.isEmpty()).toBe(true);
 
     deque.addLast(1);
@@ -267,7 +267,7 @@ describe('ArrayDeque', () => {
     expect(deque.isEmpty()).toBe(true);
   });
 
-  test('should set elements at a specific index', () => {
+  it('should set elements at a specific index', () => {
     deque.addLast(1);
     deque.addLast(2);
     deque.addLast(3);
@@ -279,7 +279,7 @@ describe('ArrayDeque', () => {
     expect(deque.get(2)).toBe(3);
   });
 
-  test('should insert elements at a specific index', () => {
+  it('should insert elements at a specific index', () => {
     deque.addLast(1);
     deque.addLast(2);
     deque.addLast(3);
@@ -293,7 +293,7 @@ describe('ArrayDeque', () => {
     expect(deque.get(3)).toBe(3);
   });
 
-  test('should delete elements at a specific index', () => {
+  it('should delete elements at a specific index', () => {
     deque.addLast(1);
     deque.addLast(2);
     deque.addLast(3);
@@ -314,7 +314,7 @@ describe('ObjectDeque', () => {
     deque = new ObjectDeque<number>();
   });
 
-  test('should add elements to the front of the deque', () => {
+  it('should add elements to the front of the deque', () => {
     deque.addFirst(1);
     deque.addFirst(2);
 
@@ -323,7 +323,7 @@ describe('ObjectDeque', () => {
     expect(deque.getLast()).toBe(1);
   });
 
-  test('should add elements to the end of the deque', () => {
+  it('should add elements to the end of the deque', () => {
     deque.addLast(1);
     deque.addLast(2);
 
@@ -332,7 +332,7 @@ describe('ObjectDeque', () => {
     expect(deque.getLast()).toBe(2);
   });
 
-  test('should remove elements from the front of the deque', () => {
+  it('should remove elements from the front of the deque', () => {
     deque.addLast(1);
     deque.addLast(2);
 
@@ -343,7 +343,7 @@ describe('ObjectDeque', () => {
     expect(deque.getFirst()).toBe(2);
   });
 
-  test('should remove elements from the end of the deque', () => {
+  it('should remove elements from the end of the deque', () => {
     deque.addLast(1);
     deque.addLast(2);
 
@@ -354,7 +354,7 @@ describe('ObjectDeque', () => {
     expect(deque.getLast()).toBe(2);
   });
 
-  test('should return the element at the front of the deque without removing it', () => {
+  it('should return the element at the front of the deque without removing it', () => {
     deque.addFirst(1);
     deque.addFirst(2);
 
@@ -362,7 +362,7 @@ describe('ObjectDeque', () => {
     expect(deque.size).toBe(2);
   });
 
-  test('should return the element at the end of the deque without removing it', () => {
+  it('should return the element at the end of the deque without removing it', () => {
     deque.addLast(1);
     deque.addLast(2);
 
@@ -370,7 +370,7 @@ describe('ObjectDeque', () => {
     expect(deque.size).toBe(2);
   });
 
-  test('should return the correct size of the deque', () => {
+  it('should return the correct size of the deque', () => {
     deque.addFirst(1);
     deque.addLast(2);
     deque.addLast(3);
@@ -378,7 +378,7 @@ describe('ObjectDeque', () => {
     expect(deque.size).toBe(3);
   });
 
-  test('should check if the deque is empty', () => {
+  it('should check if the deque is empty', () => {
     expect(deque.isEmpty()).toBe(true);
 
     deque.addFirst(1);
@@ -386,7 +386,7 @@ describe('ObjectDeque', () => {
     expect(deque.isEmpty()).toBe(false);
   });
 
-  test('should set elements at a specific index', () => {
+  it('should set elements at a specific index', () => {
     deque.addFirst(1);
     deque.addLast(2);
     deque.addLast(3);
@@ -396,7 +396,7 @@ describe('ObjectDeque', () => {
     expect(deque.getLast()).toBe(3);
   });
 
-  test('should insert elements at a specific index', () => {
+  it('should insert elements at a specific index', () => {
     deque.addFirst(1);
     deque.addLast(2);
     deque.addLast(3);

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

@@ -761,7 +761,7 @@ describe('Trie operations', () => {
     trie = new Trie();
   });
 
-  test('Add and Find Words', () => {
+  it('Add and Find Words', () => {
     trie.add('apple');
     trie.add('banana');
     expect(trie.has('apple')).toBe(true);
@@ -769,7 +769,7 @@ describe('Trie operations', () => {
     expect(trie.has('cherry')).toBe(false);
   });
 
-  test('Remove Words', () => {
+  it('Remove Words', () => {
     trie.add('apple');
     trie.add('banana');
     expect(trie.delete('apple')).toBe(true);
@@ -777,39 +777,39 @@ describe('Trie operations', () => {
     expect(trie.delete('cherry')).toBe(false);
   });
 
-  test('Case Sensitivity', () => {
+  it('Case Sensitivity', () => {
     const caseInsensitiveTrie = new Trie(['apple', 'Banana'], false);
     expect(caseInsensitiveTrie.has('APPLE')).toBe(true);
     expect(caseInsensitiveTrie.has('banana')).toBe(true);
     expect(caseInsensitiveTrie.has('Cherry')).toBe(false);
   });
 
-  test('Pure Prefix Check', () => {
+  it('Pure Prefix Check', () => {
     trie.add('apple');
     expect(trie.hasPurePrefix('appl')).toBe(true);
     expect(trie.hasPurePrefix('apple')).toBe(false);
   });
 
-  test('Prefix Check', () => {
+  it('Prefix Check', () => {
     trie.add('apple');
     expect(trie.hasPrefix('app')).toBe(true);
     expect(trie.hasPrefix('ban')).toBe(false);
   });
 
-  test('Common Prefix Check', () => {
+  it('Common Prefix Check', () => {
     trie.add('apple');
     trie.add('appetizer');
     expect(trie.hasCommonPrefix('app')).toBe(true);
     expect(trie.hasCommonPrefix('apple')).toBe(false);
   });
 
-  test('Longest Common Prefix', () => {
+  it('Longest Common Prefix', () => {
     trie.add('apple');
     trie.add('appetizer');
     expect(trie.getLongestCommonPrefix()).toBe('app');
   });
 
-  test('Get Words by Prefix', () => {
+  it('Get Words by Prefix', () => {
     trie.add('apple');
     trie.add('appetizer');
     trie.add('banana');
@@ -817,7 +817,7 @@ describe('Trie operations', () => {
     expect(words).toEqual(['apple', 'appetizer']);
   });
 
-  test('Tree Height', () => {
+  it('Tree Height', () => {
     trie.add('apple');
     trie.add('banana');
     expect(trie.getHeight()).toBe(6); // Assuming 'apple' and 'banana' are the longest words.

package/test/utils/array.ts

@@ -1,6 +1,6 @@
 import {getRandomInt} from './number';
 
-export function getRandomIntArray(length: number, min: number = -1000, max: number = 1000, isDistinct = true) {
+export function getRandomIntArray(length: number = 1000, min: number = -1000, max: number = 1000, isDistinct = true) {
   if (isDistinct) {
     const set = new Set<number>();
     const ans: number[] = [];

package/test/utils/number.ts

@@ -1,4 +1,4 @@
-export function getRandomInt(min: number, max: number) {
+export function getRandomInt(min: number = 0, max: number = 1000) {
   return Math.floor(Math.random() * (max - min + 1)) + min;
 }