data-structure-typed 1.40.0-rc → 1.40.0

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

@@ -1,4 +1,4 @@
-import {HashTableNode, HashTable} from '../../../../src';
+import {HashTable, HashTableNode} from '../../../../src';
 
 describe('HashNode', () => {
   it('should create a HashNode with key and value', () => {
@@ -7,7 +7,7 @@ describe('HashNode', () => {
     const hashNode = new HashTableNode(key, value);
 
     expect(hashNode.key).toBe(key);
-    expect(hashNode.val).toBe(value);
+    expect(hashNode.value).toBe(value);
     expect(hashNode.next).toBe(null);
   });
 });
@@ -15,7 +15,9 @@ describe('HashNode', () => {
 describe('HashTable', () => {
   it('should initialize with default capacity', () => {
     const hashTable = new HashTable<string, string>();
-
+    expect(hashTable.capacity).toBe(16);
+    expect(hashTable.buckets).toEqual(new Array(16).fill(null));
+    expect(hashTable.hashFn('a')).toBe(6);
     expect(hashTable.capacity).toBe(16);
     expect(hashTable.size).toBe(0);
     expect(hashTable.buckets.length).toBe(16);
@@ -81,13 +83,13 @@ describe('HashTable', () => {
     expect(retrievedValue).toBeUndefined();
   });
 
-  it('should remove key-value pair correctly', () => {
+  it('should delete key-value pair correctly', () => {
     const hashTable = new HashTable<string, string>();
     const key = 'testKey';
     const value = 'testValue';
 
     hashTable.set(key, value);
-    hashTable.remove(key);
+    hashTable.delete(key);
 
     const retrievedValue = hashTable.get(key);
 
@@ -128,10 +130,10 @@ describe('HashTable', () => {
     expect(hashTable.get('two')).toBe(2);
   });
 
-  it('should remove values correctly', () => {
+  it('should delete values correctly', () => {
     hashTable.set('one', 1);
     hashTable.set('two', 2);
-    hashTable.remove('one');
+    hashTable.delete('one');
 
     expect(hashTable.get('one')).toBeUndefined();
     expect(hashTable.get('two')).toBe(2);
@@ -139,7 +141,7 @@ describe('HashTable', () => {
 
   it('should handle non-existent keys correctly', () => {
     expect(hashTable.get('non-existent')).toBeUndefined();
-    hashTable.remove('non-existent'); // Removing a non-existent key should not cause errors
+    hashTable.delete('non-existent'); // Removing a non-existent key should not cause errors
   });
 
   it('should handle custom hash function correctly', () => {

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

@@ -1,4 +1,5 @@
-import {MaxHeap, MinHeap} from '../../../../src';
+import {FibonacciHeap, MaxHeap, MinHeap} from '../../../../src';
+import {logBigOMetricsWrap} from '../../../utils';
 
 describe('Heap Operation Test', () => {
   it('should numeric heap work well', function () {
@@ -21,35 +22,232 @@ describe('Heap Operation Test', () => {
   });
 
   it('should object heap work well', function () {
-    const minHeap = new MinHeap<{a: string}>();
-    minHeap.add(1, {a: 'a1'});
-    minHeap.add(6, {a: 'a6'});
-    minHeap.add(2, {a: 'a2'});
-    minHeap.add(0, {a: 'a0'});
-
-    expect(minHeap.peek()).toEqual({a: 'a0'});
-    expect(minHeap.toArray()).toEqual([{a: 'a0'}, {a: 'a1'}, {a: 'a2'}, {a: 'a6'}]);
+    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'});
+    minHeap.add({key: 0, a: 'a0'});
+
+    expect(minHeap.peek()).toEqual({a: 'a0', key: 0});
+    expect(minHeap.toArray().map(item => ({a: item.a}))).toEqual([{a: 'a0'}, {a: 'a1'}, {a: 'a2'}, {a: 'a6'}]);
     let i = 0;
     const expectPolled = [{a: 'a0'}, {a: 'a1'}, {a: 'a2'}, {a: 'a6'}];
     while (minHeap.size > 0) {
-      expect(minHeap.poll()).toEqual(expectPolled[i]);
+      expect({a: minHeap.poll()?.a}).toEqual(expectPolled[i]);
       i++;
     }
 
-    const maxHeap = new MaxHeap<{a: string}>();
-    maxHeap.add(1, {a: 'a1'});
-    maxHeap.add(6, {a: 'a6'});
-    maxHeap.add(5, {a: 'a5'});
-    maxHeap.add(2, {a: 'a2'});
-    maxHeap.add(0, {a: 'a0'});
-    maxHeap.add(9, {a: 'a9'});
-    expect(maxHeap.peek()).toEqual({a: 'a9'});
-    expect(maxHeap.toArray()).toEqual([{a: 'a9'}, {a: 'a2'}, {a: 'a6'}, {a: 'a1'}, {a: 'a0'}, {a: 'a5'}]);
+    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'});
+    maxHeap.add({key: 2, a: 'a2'});
+    maxHeap.add({key: 0, a: 'a0'});
+    maxHeap.add({key: 9, a: 'a9'});
+    expect(maxHeap.peek()).toEqual({a: 'a9', key: 9});
+    expect(maxHeap.toArray().map(item => ({a: item.a}))).toEqual([
+      {a: 'a9'},
+      {a: 'a2'},
+      {a: 'a6'},
+      {a: 'a1'},
+      {a: 'a0'},
+      {a: 'a5'}
+    ]);
     const maxExpectPolled = [{a: 'a9'}, {a: 'a6'}, {a: 'a5'}, {a: 'a2'}, {a: 'a1'}, {a: 'a0'}];
     let maxI = 0;
     while (maxHeap.size > 0) {
-      expect(maxHeap.poll()).toEqual(maxExpectPolled[maxI]);
+      expect({a: maxHeap.poll()?.a}).toEqual(maxExpectPolled[maxI]);
       maxI++;
     }
   });
 });
+
+describe('FibonacciHeap', () => {
+  let heap: FibonacciHeap<number>;
+
+  beforeEach(() => {
+    heap = new FibonacciHeap<number>();
+  });
+
+  test('push & peek', () => {
+    heap.push(10);
+    heap.push(5);
+    expect(heap.peek()).toBe(5);
+  });
+
+  test('pop', () => {
+    heap.push(10);
+    heap.push(5);
+    heap.push(15);
+    expect(heap.pop()).toBe(5);
+    expect(heap.pop()).toBe(10);
+    expect(heap.pop()).toBe(15);
+  });
+
+  test('pop on an empty heap', () => {
+    expect(heap.pop()).toBeUndefined();
+  });
+
+  test('size', () => {
+    expect(heap.size).toBe(0);
+    heap.push(10);
+    expect(heap.size).toBe(1);
+    heap.pop();
+    expect(heap.size).toBe(0);
+  });
+
+  test('clear', () => {
+    heap.push(10);
+    heap.push(5);
+    heap.clear();
+    expect(heap.size).toBe(0);
+    expect(heap.peek()).toBeUndefined();
+  });
+
+  test('custom comparator', () => {
+    const maxHeap = new FibonacciHeap<number>((a, b) => b - a);
+    maxHeap.push(10);
+    maxHeap.push(5);
+    expect(maxHeap.peek()).toBe(10);
+  });
+});
+
+describe('FibonacciHeap', () => {
+  let heap: FibonacciHeap<number>;
+
+  beforeEach(() => {
+    heap = new FibonacciHeap<number>();
+  });
+
+  it('should initialize an empty heap', () => {
+    expect(heap.size).toBe(0);
+    expect(heap.peek()).toBeUndefined();
+  });
+
+  it('should push items into the heap and update size', () => {
+    heap.push(10);
+    heap.push(5);
+
+    expect(heap.size).toBe(2);
+  });
+
+  it('should peek the minimum item', () => {
+    heap.push(10);
+    heap.push(5);
+    heap.push(15);
+
+    expect(heap.peek()).toBe(5);
+  });
+
+  it('should pop the minimum item and update size', () => {
+    heap.push(10);
+    heap.push(5);
+    heap.push(15);
+
+    const minItem = heap.pop();
+
+    expect(minItem).toBe(5);
+    expect(heap.size).toBe(2);
+  });
+
+  it('should correctly merge two heaps', () => {
+    const heap1 = new FibonacciHeap<number>();
+    const heap2 = new FibonacciHeap<number>();
+
+    heap1.push(10);
+    heap2.push(5);
+
+    heap1.merge(heap2);
+
+    expect(heap1.size).toBe(2);
+    expect(heap1.peek()).toBe(5);
+  });
+
+  it('should clear the heap', () => {
+    heap.push(10);
+    heap.push(5);
+
+    heap.clear();
+
+    expect(heap.size).toBe(0);
+    expect(heap.peek()).toBeUndefined();
+  });
+
+  it('should handle custom comparators', () => {
+    const customComparator = (a: number, b: number) => b - a;
+    const customHeap = new FibonacciHeap<number>(customComparator);
+
+    customHeap.push(10);
+    customHeap.push(5);
+    customHeap.push(15);
+
+    expect(customHeap.peek()).toBe(15);
+  });
+
+  describe('FibonacciHeap Merge', () => {
+    it('should merge two Fibonacci heaps correctly', () => {
+      const heap1 = new FibonacciHeap<number>();
+      heap1.push(5).push(10);
+
+      const heap2 = new FibonacciHeap<number>();
+      heap2.push(3).push(7);
+
+      heap1.merge(heap2);
+
+      expect(heap1.size).toBe(4); // Combined size of both heaps
+      expect(heap2.size).toBe(0); // Merged heap should be empty
+      expect(heap1.peek()).toBe(3); // Minimum element should be 3
+    });
+  });
+});
+
+describe('FibonacciHeap Stress Test', () => {
+  it('should handle a large number of elements efficiently', () => {
+    const testByMagnitude = (magnitude: number) => {
+      const heap = new FibonacciHeap<number>();
+
+      // Add 1000 elements to the heap
+      for (let i = 1; i <= magnitude; i++) {
+        heap.push(i);
+      }
+
+      // Verify that the minimum element is 1 (smallest element)
+      expect(heap.peek()).toBe(1);
+
+      // Remove all 1000 elements from the heap
+      const elements = [];
+      while (heap.size > 0) {
+        elements.push(heap.pop());
+      }
+
+      // Verify that all elements were removed in ascending order
+      for (let i = 1; i <= magnitude; i++) {
+        expect(elements[i - 1]).toBe(i);
+      }
+
+      // Verify that the heap is now empty
+      expect(heap.size).toBe(0);
+    };
+
+    testByMagnitude(1000);
+
+    // [
+    //   10, 100, 1000, 5000, 10000, 20000, 50000, 75000, 100000,
+    //   150000, 200000, 250000, 300000, 400000, 500000, 600000, 700000, 800000, 900000, 1000000
+    // ].forEach(m => logBigOMetricsWrap<typeof testByMagnitude>(testByMagnitude, [m]));
+    [
+      10, 100, 1000, 5000, 10000, 20000, 50000, 75000, 100000, 150000, 200000, 250000, 300000, 400000, 500000, 600000,
+      700000, 800000, 900000, 1000000
+    ].forEach(m =>
+      logBigOMetricsWrap(
+        (c: number) => {
+          const result: number[] = [];
+          for (let i = 0; i < c; i++) result.push(i);
+          return result;
+        },
+        [m],
+        'loopPush'
+      )
+    );
+  });
+});

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

@@ -1,44 +1,52 @@
-import {HeapItem, MaxHeap} from '../../../../src';
-
-describe('MaxHeap Operation Test', () => {
-  it('should object Max Heap operations be proper', function () {
-    const maxHeap = new MaxHeap<{keyA: string}>();
-    const myObj1 = {keyA: 'a1'},
-      myObj6 = {keyA: 'a6'},
-      myObj5 = {keyA: 'a5'},
-      myObj2 = {keyA: 'a2'},
-      myObj0 = {keyA: 'a0'},
-      myObj9 = {keyA: 'a9'};
-    maxHeap.add(1, myObj1);
-    expect(maxHeap.has(myObj1)).toBe(true);
-    expect(maxHeap.has(myObj9)).toBe(false);
-    maxHeap.add(6, myObj6);
-    expect(maxHeap.has(myObj6)).toBe(true);
-    maxHeap.add(5, myObj5);
-    expect(maxHeap.has(myObj5)).toBe(true);
-    maxHeap.add(2, myObj2);
-    expect(maxHeap.has(myObj2)).toBe(true);
-    expect(maxHeap.has(myObj6)).toBe(true);
-    maxHeap.add(0, myObj0);
-    expect(maxHeap.has(myObj0)).toBe(true);
-    expect(maxHeap.has(myObj9)).toBe(false);
-    maxHeap.add(9, myObj9);
-    expect(maxHeap.has(myObj9)).toBe(true);
-
-    const peek9 = maxHeap.peek(true);
-    peek9 && peek9.val && expect(peek9.val.keyA).toBe('a9');
-
-    const heapToArr = maxHeap.toArray(true);
-    expect(heapToArr.map(item => item?.val?.keyA)).toEqual(['a9', 'a2', 'a6', 'a1', 'a0', 'a5']);
-
-    const values = ['a9', 'a6', 'a5', 'a2', 'a1', 'a0'];
-    let i = 0;
-    while (maxHeap.size > 0) {
-      const polled = maxHeap.poll(true);
-      expect(polled).toBeInstanceOf(HeapItem);
-      polled && expect(polled.val).toHaveProperty('keyA');
-      polled && polled.val && expect(polled.val.keyA).toBe(values[i]);
-      i++;
-    }
+import {Comparator, MaxHeap} from '../../../../src';
+
+describe('MaxHeap', () => {
+  const numberComparator: Comparator<number> = (a, b) => b - a;
+  let maxHeap: MaxHeap<number>;
+
+  beforeEach(() => {
+    maxHeap = new MaxHeap({comparator: numberComparator});
+  });
+
+  test('add and poll elements in descending order', () => {
+    maxHeap.add(3);
+    maxHeap.add(1);
+    maxHeap.add(4);
+    maxHeap.add(2);
+
+    expect(maxHeap.poll()).toBe(4);
+    expect(maxHeap.poll()).toBe(3);
+    expect(maxHeap.poll()).toBe(2);
+    expect(maxHeap.poll()).toBe(1);
+  });
+
+  test('peek at the top element without removing it', () => {
+    maxHeap.add(3);
+    maxHeap.add(1);
+    maxHeap.add(4);
+    maxHeap.add(2);
+
+    expect(maxHeap.peek()).toBe(4);
+    expect(maxHeap.size).toBe(4);
+  });
+
+  test('sort elements in descending order', () => {
+    maxHeap.add(3);
+    maxHeap.add(1);
+    maxHeap.add(4);
+    maxHeap.add(2);
+
+    const sortedArray = maxHeap.sort();
+    expect(sortedArray).toEqual([4, 3, 2, 1]);
+  });
+
+  test('check if the heap is empty', () => {
+    expect(maxHeap.isEmpty()).toBe(true);
+
+    maxHeap.add(5);
+    expect(maxHeap.isEmpty()).toBe(false);
+
+    maxHeap.poll();
+    expect(maxHeap.isEmpty()).toBe(true);
   });
 });

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

@@ -1,82 +1,52 @@
-import {HeapItem, MinHeap} from '../../../../src';
+import {Comparator, MinHeap} from '../../../../src';
 
-describe('MinHeap Operation Test', () => {
-  it('should numeric Min Heap operations be proper', function () {
-    const minNumHeap = new MinHeap<number>();
-    expect(minNumHeap).toBeInstanceOf(MinHeap);
+describe('MinHeap', () => {
+  const numberComparator: Comparator<number> = (a, b) => a - b;
+  let minHeap: MinHeap<number>;
 
-    minNumHeap.add(1);
-    expect(minNumHeap.has(1)).toBe(true);
-    minNumHeap.add(6);
-    expect(minNumHeap.has(2)).toBe(false);
-    expect(minNumHeap.has(6)).toBe(true);
-    minNumHeap.add(2);
-    expect(minNumHeap.has(2)).toBe(true);
-    minNumHeap.add(0);
-    expect(minNumHeap.has(0)).toBe(true);
-    minNumHeap.add(5);
-    expect(minNumHeap.has(5)).toBe(true);
-    minNumHeap.add(9);
-    expect(minNumHeap.has(9)).toBe(true);
-    expect(minNumHeap.size).toBe(6);
-
-    const poll1 = minNumHeap.poll(true);
-    expect(poll1).toBeInstanceOf(HeapItem);
-    poll1 instanceof HeapItem && expect(poll1.val).toBe(0);
-
-    const poll2 = minNumHeap.poll(true);
-    expect(poll2).toBeInstanceOf(HeapItem);
-    poll2 instanceof HeapItem && expect(poll2.val).toBe(1);
+  beforeEach(() => {
+    minHeap = new MinHeap({comparator: numberComparator});
+  });
 
-    const peek1 = minNumHeap.peek(true);
-    expect(peek1).toBeInstanceOf(HeapItem);
-    peek1 instanceof HeapItem && expect(peek1.val).toBe(2);
+  test('add and poll elements in ascending order', () => {
+    minHeap.add(3);
+    minHeap.add(1);
+    minHeap.add(4);
+    minHeap.add(2);
 
-    const heapArray = minNumHeap.toArray(true);
-    expect(heapArray).toBeInstanceOf(Array);
-    expect(heapArray.map(item => item?.priority)).toEqual([2, 5, 9, 6]);
-    expect(minNumHeap.size).toBe(4);
+    expect(minHeap.poll()).toBe(1);
+    expect(minHeap.poll()).toBe(2);
+    expect(minHeap.poll()).toBe(3);
+    expect(minHeap.poll()).toBe(4);
   });
 
-  it('should object Min Heap operations be proper', function () {
-    class MyObject {
-      keyA: string;
+  test('peek at the top element without removing it', () => {
+    minHeap.add(3);
+    minHeap.add(1);
+    minHeap.add(4);
+    minHeap.add(2);
 
-      constructor(keyA: string) {
-        this.keyA = keyA;
-      }
-    }
+    expect(minHeap.peek()).toBe(1);
+    expect(minHeap.size).toBe(4);
+  });
 
-    const minObjHeap = new MinHeap<MyObject>();
+  test('sort elements in ascending order', () => {
+    minHeap.add(3);
+    minHeap.add(1);
+    minHeap.add(4);
+    minHeap.add(2);
 
-    const obj1 = new MyObject('a1'),
-      obj6 = new MyObject('a6'),
-      obj2 = new MyObject('a2'),
-      obj0 = new MyObject('a0');
-    minObjHeap.add(1, obj1);
-    expect(minObjHeap.has(obj1)).toBe(true);
-    expect(minObjHeap.has(obj6)).toBe(false);
-    minObjHeap.add(6, obj6);
-    expect(minObjHeap.has(obj6)).toBe(true);
-    minObjHeap.add(2, obj2);
-    expect(minObjHeap.has(obj2)).toBe(true);
-    minObjHeap.add(0, obj0);
-    expect(minObjHeap.has(obj0)).toBe(true);
+    const sortedArray = minHeap.sort();
+    expect(sortedArray).toEqual([1, 2, 3, 4]);
+  });
 
-    const peek = minObjHeap.peek(true);
-    peek && peek.val && expect(peek.val.keyA).toBe('a0');
+  test('check if the heap is empty', () => {
+    expect(minHeap.isEmpty()).toBe(true);
 
-    const heapToArr = minObjHeap.toArray(true);
-    expect(heapToArr.map(item => item?.val?.keyA)).toEqual(['a0', 'a1', 'a2', 'a6']);
+    minHeap.add(5);
+    expect(minHeap.isEmpty()).toBe(false);
 
-    const values = ['a0', 'a1', 'a2', 'a6'];
-    let i = 0;
-    while (minObjHeap.size > 0) {
-      const polled = minObjHeap.poll(true);
-      expect(polled).toBeInstanceOf(HeapItem);
-      polled && expect(polled.val).toBeInstanceOf(MyObject);
-      polled && polled.val && expect(polled.val.keyA).toBe(values[i]);
-      i++;
-    }
+    minHeap.poll();
+    expect(minHeap.isEmpty()).toBe(true);
   });
 });