data-structure-typed 2.4.1 → 2.4.3

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

@@ -1,760 +0,0 @@
-import { FibonacciHeap, Heap, MaxHeap, MinHeap } from '../../../../src';
-import { logBigOMetricsWrap } from '../../../utils';
-
-describe('Heap Operation Test', () => {
-  it('should initiate heap', function () {
-    const hp = new Heap<number>();
-    hp.add(1);
-    expect(hp.size).toBe(1);
-  });
-
-  it('should heap add and delete work well', function () {
-    const hp = new MinHeap<number>();
-    expect(hp.delete(1)).toBe(false);
-    hp.add(2);
-    hp.add(3);
-    hp.add(1);
-    hp.add(4);
-    hp.add(6);
-    hp.add(5);
-    hp.add(7);
-
-    hp.delete(4);
-    hp.delete(7);
-    hp.delete(1);
-
-    expect(hp.size).toBe(4);
-    expect(hp.peek()).toBe(2);
-  });
-
-  it('should numeric heap work well', function () {
-    const minNumHeap = new MinHeap<number>();
-    expect(minNumHeap.poll()).toBe(undefined);
-    minNumHeap.add(1);
-    minNumHeap.add(6);
-    minNumHeap.add(2);
-    minNumHeap.add(0);
-    minNumHeap.add(5);
-    minNumHeap.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 clone', function () {
-    const minNumHeap = new Heap<string>([], {
-      comparator: (a, b) => Number(a) - Number(b)
-    });
-    minNumHeap.add('1');
-    minNumHeap.add('6');
-    minNumHeap.add('2');
-    minNumHeap.add('0');
-    minNumHeap.add('5');
-    minNumHeap.add('9');
-    minNumHeap.delete('2');
-    expect([...minNumHeap]).toEqual(['0', '1', '9', '6', '5']);
-    const cloned = minNumHeap.clone();
-    expect([...cloned]).toEqual(['0', '1', '9', '6', '5']);
-    minNumHeap.delete('5');
-    expect([...minNumHeap]).toEqual(['0', '1', '9', '6']);
-    expect([...cloned]).toEqual(['0', '1', '9', '6', '5']);
-  });
-
-  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++;
-    }
-  });
-
-  it('should object heap map & filter', function () {
-    const minHeap = new MinHeap<{
-      a: string;
-      key: number;
-    }>(
-      [
-        { key: 1, a: 'a1' },
-        { key: 6, a: 'a6' },
-        { key: 5, a: 'a5' },
-        { key: 3, a: 'a3' },
-        { key: 2, a: 'a2' },
-        { key: 4, a: 'a4' },
-        { key: 0, a: 'a0' }
-      ],
-      {
-        comparator: (a, b) => a.key - b.key
-      }
-    );
-
-    const mappedMinHeap = minHeap.map(item => item.key, { comparator: (a, b) => a - b });
-    expect(mappedMinHeap.peek()).toBe(0);
-    expect(mappedMinHeap.sort()).toEqual([0, 1, 2, 3, 4, 5, 6]);
-
-    const mappedToElementFnMinHeap = minHeap.map<string, { id: string }>(item => item.key.toString(), {
-      comparator: (a, b) => Number(a) - Number(b),
-      toElementFn: rawElement => rawElement.id
-    });
-    expect(mappedToElementFnMinHeap.peek()).toBe('0');
-    expect(mappedToElementFnMinHeap.sort()).toEqual(['0', '1', '2', '3', '4', '5', '6']);
-
-    const filteredHeap = minHeap.filter(item => item.key > 3);
-    expect(filteredHeap.peek()).toEqual({ a: 'a4', key: 4 });
-    expect(filteredHeap.sort()).toEqual([
-      { a: 'a4', key: 4 },
-      { a: 'a5', key: 5 },
-      { a: 'a6', key: 6 }
-    ]);
-  });
-
-  it('should object heap', () => {
-    const heap = new Heap<{
-      rawItem: { id: number };
-    }>(
-      [
-        { rawItem: { id: 4 } },
-        { rawItem: { id: 8 } },
-        { rawItem: { id: 6 } },
-        { rawItem: { id: 7 } },
-        { rawItem: { id: 1 } },
-        { rawItem: { id: 3 } },
-        { rawItem: { id: 5 } }
-      ],
-      {
-        comparator: (a, b) => a.rawItem.id - b.rawItem.id
-      }
-    );
-
-    expect([...heap.sort()]).toEqual([
-      { rawItem: { id: 1 } },
-      { rawItem: { id: 3 } },
-      { rawItem: { id: 4 } },
-      { rawItem: { id: 5 } },
-      { rawItem: { id: 6 } },
-      { rawItem: { id: 7 } },
-      { rawItem: { id: 8 } }
-    ]);
-  });
-
-  it('should toElementFn', () => {
-    const heap = new Heap<number, { rawItem: { id: number } }>(
-      [
-        { rawItem: { id: 4 } },
-        { rawItem: { id: 8 } },
-        { rawItem: { id: 6 } },
-        { rawItem: { id: 7 } },
-        { rawItem: { id: 1 } },
-        { rawItem: { id: 3 } },
-        { rawItem: { id: 5 } }
-      ],
-      {
-        toElementFn: rawElement => rawElement.rawItem.id
-      }
-    );
-
-    expect([...heap.sort()]).toEqual([1, 3, 4, 5, 6, 7, 8]);
-  });
-
-  it('should getter leaf', function () {
-    const hp = new Heap<number>();
-    expect(hp.leaf).toBe(undefined);
-    hp.add(1);
-    expect(hp.leaf).toBe(1);
-  });
-
-  // it('should error', function () {
-  //   expect(() => {
-  //     new Heap([{ key: 1 }, { key: 2 }, { key: 3 }]);
-  //   }).toThrow(
-  //     "When comparing object types, a custom comparator must be defined in the constructor's options parameter."
-  //   );
-  // });
-});
-
-describe('Heap HOF', () => {
-  let hp: Heap<{ key: number }, { key: number }>;
-
-  beforeEach(() => {
-    hp = new Heap([{ key: 1 }, { key: 2 }, { key: 3 }], { comparator: (a, b) => a.key - b.key });
-  });
-
-  it('should filter', () => {
-    const filtered = hp.filter(({ key }) => key % 2 === 1);
-    expect([...filtered]).toEqual([{ key: 1 }, { key: 3 }]);
-  });
-
-  it('should map', () => {
-    const mapped = hp.map(({ key }) => [key, key], { comparator: (a, b) => a[0] - b[0] });
-    expect([...mapped]).toEqual([
-      [1, 1],
-      [2, 2],
-      [3, 3]
-    ]);
-  });
-});
-describe('FibonacciHeap', () => {
-  let heap: FibonacciHeap<number>;
-
-  beforeEach(() => {
-    heap = new FibonacciHeap<number>();
-  });
-
-  it('push & peek', () => {
-    heap.push(10);
-    heap.push(5);
-    expect(heap.peek()).toBe(5);
-  });
-
-  it('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);
-  });
-
-  it('pop on an empty heap', () => {
-    expect(heap.pop()).toBeUndefined();
-  });
-
-  it('size', () => {
-    expect(heap.size).toBe(0);
-    heap.push(10);
-    expect(heap.size).toBe(1);
-    heap.pop();
-    expect(heap.size).toBe(0);
-  });
-
-  it('clear', () => {
-    heap.push(10);
-    heap.push(5);
-    heap.clear();
-    expect(heap.size).toBe(0);
-    expect(heap.peek()).toBeUndefined();
-  });
-
-  it('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'
-      )
-    );
-  });
-});
-
-describe('classic use', () => {
-  it('@example basic Heap creation and add operation', () => {
-    // Create a min heap (default)
-    const minHeap = new Heap([5, 3, 7, 1, 9, 2]);
-
-    // Verify size
-    expect(minHeap.size).toBe(6);
-
-    // Add new element
-    minHeap.add(4);
-    expect(minHeap.size).toBe(7);
-
-    // Min heap property: smallest element at root
-    const min = minHeap.peek();
-    expect(min).toBe(1);
-  });
-
-  it('@example Heap with custom comparator (MaxHeap behavior)', () => {
-    interface Task {
-      id: number;
-      priority: number;
-      name: string;
-    }
-
-    // Custom comparator for max heap behavior (higher priority first)
-    const tasks: Task[] = [
-      { id: 1, priority: 5, name: 'Email' },
-      { id: 2, priority: 3, name: 'Chat' },
-      { id: 3, priority: 8, name: 'Alert' }
-    ];
-
-    const maxHeap = new Heap(tasks, {
-      comparator: (a: Task, b: Task) => b.priority - a.priority
-    });
-
-    expect(maxHeap.size).toBe(3);
-
-    // Peek returns highest priority task
-    const topTask = maxHeap.peek();
-    expect(topTask?.priority).toBe(8);
-    expect(topTask?.name).toBe('Alert');
-  });
-
-  it('@example Heap for event processing with priority', () => {
-    interface Event {
-      id: number;
-      type: 'critical' | 'warning' | 'info';
-      timestamp: number;
-      message: string;
-    }
-
-    // Custom priority: critical > warning > info
-    const priorityMap = { critical: 3, warning: 2, info: 1 };
-
-    const eventHeap = new Heap<Event>([], {
-      comparator: (a: Event, b: Event) => {
-        const priorityA = priorityMap[a.type];
-        const priorityB = priorityMap[b.type];
-        return priorityB - priorityA; // Higher priority first
-      }
-    });
-
-    // Add events in random order
-    eventHeap.add({ id: 1, type: 'info', timestamp: 100, message: 'User logged in' });
-    eventHeap.add({ id: 2, type: 'critical', timestamp: 101, message: 'Server down' });
-    eventHeap.add({ id: 3, type: 'warning', timestamp: 102, message: 'High memory' });
-    eventHeap.add({ id: 4, type: 'info', timestamp: 103, message: 'Cache cleared' });
-    eventHeap.add({ id: 5, type: 'critical', timestamp: 104, message: 'Database error' });
-
-    expect(eventHeap.size).toBe(5);
-
-    // Process events by priority (critical first)
-    const processedOrder: Event[] = [];
-    while (eventHeap.size > 0) {
-      const event = eventHeap.poll();
-      if (event) {
-        processedOrder.push(event);
-      }
-    }
-
-    // Verify critical events came first
-    expect(processedOrder[0].type).toBe('critical');
-    expect(processedOrder[1].type).toBe('critical');
-    expect(processedOrder[2].type).toBe('warning');
-    expect(processedOrder[3].type).toBe('info');
-    expect(processedOrder[4].type).toBe('info');
-
-    // Verify O(log n) operations
-    const newHeap = new Heap<number>([5, 3, 7, 1]);
-
-    // Add - O(log n)
-    newHeap.add(2);
-    expect(newHeap.size).toBe(5);
-
-    // Poll - O(log n)
-    const removed = newHeap.poll();
-    expect(removed).toBe(1);
-
-    // Peek - O(1)
-    const top = newHeap.peek();
-    expect(top).toBe(2);
-  });
-
-  it('@example Use Heap to solve top k problems', () => {
-    function topKElements(arr: number[], k: number): number[] {
-      const heap = new Heap<number>([], { comparator: (a, b) => b - a }); // Max heap
-      arr.forEach(num => {
-        heap.add(num);
-        if (heap.size > k) heap.poll(); // Keep the heap size at K
-      });
-      return heap.toArray();
-    }
-
-    const numbers = [10, 30, 20, 5, 15, 25];
-    expect(topKElements(numbers, 3)).toEqual([15, 10, 5]);
-  });
-
-  it('@example Use Heap to dynamically maintain the median', () => {
-    class MedianFinder {
-      private low: MaxHeap<number>; // Max heap, stores the smaller half
-      private high: MinHeap<number>; // Min heap, stores the larger half
-
-      constructor() {
-        this.low = new MaxHeap<number>([]);
-        this.high = new MinHeap<number>([]);
-      }
-
-      addNum(num: number): void {
-        if (this.low.isEmpty() || num <= this.low.peek()!) this.low.add(num);
-        else this.high.add(num);
-
-        // Balance heaps
-        if (this.low.size > this.high.size + 1) this.high.add(this.low.poll()!);
-        else if (this.high.size > this.low.size) this.low.add(this.high.poll()!);
-      }
-
-      findMedian(): number {
-        if (this.low.size === this.high.size) return (this.low.peek()! + this.high.peek()!) / 2;
-        return this.low.peek()!;
-      }
-    }
-
-    const medianFinder = new MedianFinder();
-    medianFinder.addNum(10);
-    expect(medianFinder.findMedian()).toBe(10);
-    medianFinder.addNum(20);
-    expect(medianFinder.findMedian()).toBe(15);
-    medianFinder.addNum(30);
-    expect(medianFinder.findMedian()).toBe(20);
-    medianFinder.addNum(40);
-    expect(medianFinder.findMedian()).toBe(25);
-    medianFinder.addNum(50);
-    expect(medianFinder.findMedian()).toBe(30);
-  });
-
-  it('@example Use Heap for load balancing', () => {
-    function loadBalance(requests: number[], servers: number): number[] {
-      const serverHeap = new Heap<{ id: number; load: number }>([], { comparator: (a, b) => a.load - b.load }); // min heap
-      const serverLoads = new Array(servers).fill(0);
-
-      for (let i = 0; i < servers; i++) {
-        serverHeap.add({ id: i, load: 0 });
-      }
-
-      requests.forEach(req => {
-        const server = serverHeap.poll()!;
-        serverLoads[server.id] += req;
-        server.load += req;
-        serverHeap.add(server); // The server after updating the load is re-entered into the heap
-      });
-
-      return serverLoads;
-    }
-
-    const requests = [5, 2, 8, 3, 7];
-    expect(loadBalance(requests, 3)).toEqual([12, 8, 5]);
-  });
-
-  it('@example Use Heap to schedule tasks', () => {
-    type Task = [string, number];
-
-    function scheduleTasks(tasks: Task[], machines: number): Map<number, Task[]> {
-      const machineHeap = new Heap<{ id: number; load: number }>([], { comparator: (a, b) => a.load - b.load }); // Min heap
-      const allocation = new Map<number, Task[]>();
-
-      // Initialize the load on each machine
-      for (let i = 0; i < machines; i++) {
-        machineHeap.add({ id: i, load: 0 });
-        allocation.set(i, []);
-      }
-
-      // Assign tasks
-      tasks.forEach(([task, load]) => {
-        const machine = machineHeap.poll()!;
-        allocation.get(machine.id)!.push([task, load]);
-        machine.load += load;
-        machineHeap.add(machine); // The machine after updating the load is re-entered into the heap
-      });
-
-      return allocation;
-    }
-
-    const tasks: Task[] = [
-      ['Task1', 3],
-      ['Task2', 1],
-      ['Task3', 2],
-      ['Task4', 5],
-      ['Task5', 4]
-    ];
-    const expectedMap = new Map<number, Task[]>();
-    expectedMap.set(0, [
-      ['Task1', 3],
-      ['Task4', 5]
-    ]);
-    expectedMap.set(1, [
-      ['Task2', 1],
-      ['Task3', 2],
-      ['Task5', 4]
-    ]);
-    expect(scheduleTasks(tasks, 2)).toEqual(expectedMap);
-  });
-
-  it('Use Heap to sort an array', () => {
-    function heapSort(arr: number[]): number[] {
-      const heap = new Heap<number>(arr, { comparator: (a, b) => a - b });
-      const sorted: number[] = [];
-      while (!heap.isEmpty()) {
-        sorted.push(heap.poll()!); // Poll minimum element
-      }
-      return sorted;
-    }
-
-    const array = [5, 3, 8, 4, 1, 2];
-    expect(heapSort(array)).toEqual([1, 2, 3, 4, 5, 8]);
-  });
-
-  it('Heap getHeight and structure', () => {
-    const heap = new Heap<number>([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]);
-
-    // Complete binary tree (heap property)
-    expect(heap.size).toBe(15);
-
-    // Verify min heap property (parent <= children)
-    const min = heap.peek();
-    expect(min).toBe(1);
-  });
-
-  it('Heap poll and priority extraction', () => {
-    // Create max heap (higher numbers first)
-    const heap = new Heap([3, 7, 1, 9, 5], {
-      comparator: (a: number, b: number) => b - a
-    });
-
-    expect(heap.size).toBe(5);
-
-    // Poll removes and returns the highest priority element
-    const first = heap.poll();
-    expect(first).toBe(9);
-    expect(heap.size).toBe(4);
-
-    const second = heap.poll();
-    expect(second).toBe(7);
-    expect(heap.size).toBe(3);
-
-    // Remaining elements are still in heap order
-    const third = heap.peek();
-    expect(third).toBe(5);
-  });
-
-  it('Use Heap to merge sorted sequences', () => {
-    function mergeSortedSequences(sequences: number[][]): number[] {
-      const heap = new Heap<{ value: number; seqIndex: number; itemIndex: number }>([], {
-        comparator: (a, b) => a.value - b.value // Min heap
-      });
-
-      // Initialize heap
-      sequences.forEach((seq, seqIndex) => {
-        if (seq.length) {
-          heap.add({ value: seq[0], seqIndex, itemIndex: 0 });
-        }
-      });
-
-      const merged: number[] = [];
-      while (!heap.isEmpty()) {
-        const { value, seqIndex, itemIndex } = heap.poll()!;
-        merged.push(value);
-
-        if (itemIndex + 1 < sequences[seqIndex].length) {
-          heap.add({
-            value: sequences[seqIndex][itemIndex + 1],
-            seqIndex,
-            itemIndex: itemIndex + 1
-          });
-        }
-      }
-
-      return merged;
-    }
-
-    const sequences = [
-      [1, 4, 7],
-      [2, 5, 8],
-      [3, 6, 9]
-    ];
-    expect(mergeSortedSequences(sequences)).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9]);
-  });
-});