data-structure-typed 1.41.6 → 1.41.8

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

@@ -0,0 +1,254 @@
+import {FibonacciHeap, MaxHeap, MinHeap} from '../../../../src';
+import {logBigOMetricsWrap} from '../../../utils';
+
+describe('Heap Operation Test', () => {
+  it('should numeric heap work well', function () {
+    const minNumHeap = new MinHeap<number>();
+    minNumHeap.add(1).add(6).add(2).add(0).add(5).add(9);
+    expect(minNumHeap.has(1)).toBe(true);
+    expect(minNumHeap.has(2)).toBe(true);
+    expect(minNumHeap.poll()).toBe(0);
+    expect(minNumHeap.poll()).toBe(1);
+    expect(minNumHeap.peek()).toBe(2);
+    expect(!minNumHeap.has(1));
+    expect(minNumHeap.has(2));
+    const arrFromHeap = minNumHeap.toArray();
+    expect(arrFromHeap.length).toBe(4);
+    expect(arrFromHeap[0]).toBe(2);
+    expect(arrFromHeap[1]).toBe(5);
+    expect(arrFromHeap[2]).toBe(9);
+    expect(arrFromHeap[3]).toBe(6);
+    expect(minNumHeap.sort()).toEqual([2, 5, 6, 9]);
+  });
+
+  it('should object heap work well', function () {
+    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({a: minHeap.poll()?.a}).toEqual(expectPolled[i]);
+      i++;
+    }
+
+    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({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
+    // ]
+    [10, 100, 1000, 5000].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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,52 @@
+import {Comparator, MinHeap} from '../../../../src';
+
+describe('MinHeap', () => {
+  const numberComparator: Comparator<number> = (a, b) => a - b;
+  let minHeap: MinHeap<number>;
+
+  beforeEach(() => {
+    minHeap = new MinHeap({comparator: numberComparator});
+  });
+
+  test('add and poll elements in ascending order', () => {
+    minHeap.add(3);
+    minHeap.add(1);
+    minHeap.add(4);
+    minHeap.add(2);
+
+    expect(minHeap.poll()).toBe(1);
+    expect(minHeap.poll()).toBe(2);
+    expect(minHeap.poll()).toBe(3);
+    expect(minHeap.poll()).toBe(4);
+  });
+
+  test('peek at the top element without removing it', () => {
+    minHeap.add(3);
+    minHeap.add(1);
+    minHeap.add(4);
+    minHeap.add(2);
+
+    expect(minHeap.peek()).toBe(1);
+    expect(minHeap.size).toBe(4);
+  });
+
+  test('sort elements in ascending order', () => {
+    minHeap.add(3);
+    minHeap.add(1);
+    minHeap.add(4);
+    minHeap.add(2);
+
+    const sortedArray = minHeap.sort();
+    expect(sortedArray).toEqual([1, 2, 3, 4]);
+  });
+
+  test('check if the heap is empty', () => {
+    expect(minHeap.isEmpty()).toBe(true);
+
+    minHeap.add(5);
+    expect(minHeap.isEmpty()).toBe(false);
+
+    minHeap.poll();
+    expect(minHeap.isEmpty()).toBe(true);
+  });
+});