heap-typed 1.53.5 → 1.53.6

package/README.md

@@ -30,225 +30,190 @@ npm i heap-typed --save
 yarn add heap-typed
 ```
 
-### methods
-
-Min Heap
-![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/methods-8bit/min-heap.png?raw=true)
-Max Heap
-![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/methods-8bit/max-heap.png?raw=true)
-
 ### snippet
 
-#### heap sort TS
+[//]: # (No deletion!!! Start of Example Replace Section)
 
+### Use Heap to sort an array
 ```typescript
-    import {Heap, MaxHeap, MinHeap} from 'data-structure-typed';
-
-// /* or if you prefer */ import {MinHeap, MaxHeap} from 'heap-typed';
-
-// 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()) {
+      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;
     }
-    return sorted;
-}
-
-console.log('Heap sorted:', heapSort([5, 3, 8, 4, 1, 2]));  // [1, 2, 3, 4, 5, 8];
 
+    const array = [5, 3, 8, 4, 1, 2];
+    console.log(heapSort(array)); // [1, 2, 3, 4, 5, 8]
 ```
 
-
-#### top K problem TS
-
+### Use Heap to solve top k problems
 ```typescript
-// Use Heap to resolve top K problem
 function topKElements(arr: number[], k: number): number[] {
-    const heap = new Heap<number>([], {comparator: (a, b) => b - a}); // Max heap
-    arr.forEach((num) => {
+      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();
-}
+      });
+      return heap.toArray();
+    }
 
-const numbers = [10, 30, 20, 5, 15, 25];
-console.log('Top K:', topKElements(numbers, 3)); // [15, 10, 5]
+    const numbers = [10, 30, 20, 5, 15, 25];
+    console.log(topKElements(numbers, 3)); // [15, 10, 5]
 ```
 
-#### real-time median TS
+### Use Heap to merge sorted sequences
+```typescript
+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]
+    ];
+    console.log(mergeSortedSequences(sequences)); // [1, 2, 3, 4, 5, 6, 7, 8, 9]
+```
 
+### Use Heap to dynamically maintain the median
 ```typescript
-// Use Heap to maintain median value for real-time retrieval
 class MedianFinder {
-    private low: MaxHeap<number>; // Max heap, stores the smaller half
-    private high: MinHeap<number>; // Min heap, stores the larger half
+      private low: MaxHeap<number>; // Max heap, stores the smaller half
+      private high: MinHeap<number>; // Min heap, stores the larger half
 
-    constructor() {
+      constructor() {
         this.low = new MaxHeap<number>([]);
         this.high = new MinHeap<number>([]);
-    }
+      }
 
-    addNum(num: number): void {
+      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 {
+      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);
-console.log('realtime median: ', medianFinder.findMedian()) // 10
-medianFinder.addNum(20);
-console.log('realtime median: ', medianFinder.findMedian()) // 10
-medianFinder.addNum(30);
-console.log('realtime median: ', medianFinder.findMedian()) // 20
-medianFinder.addNum(40);
-console.log('realtime median: ', medianFinder.findMedian()) // 20
-medianFinder.addNum(50);
-console.log('realtime median: ', medianFinder.findMedian()) // 30
-```
 
-#### load balance TS
+    const medianFinder = new MedianFinder();
+    medianFinder.addNum(10);
+    console.log(medianFinder.findMedian()); // 10
+    medianFinder.addNum(20);
+    console.log(medianFinder.findMedian()); // 15
+    medianFinder.addNum(30);
+    console.log(medianFinder.findMedian()); // 20
+    medianFinder.addNum(40);
+    console.log(medianFinder.findMedian()); // 25
+    medianFinder.addNum(50);
+    console.log(medianFinder.findMedian()); // 30
+```
 
+### Use Heap for load balancing
 ```typescript
-// 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);
+      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++) {
+      for (let i = 0; i < servers; i++) {
         serverHeap.add({ id: i, load: 0 });
-    }
+      }
 
-    requests.forEach(req => {
+      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;
-}
+      return serverLoads;
+    }
 
-const requests = [5, 2, 8, 3, 7];
-const serversLoads = loadBalance(requests, 3);
-console.log('server loads: ', serversLoads);  // [12, 8, 5]
+    const requests = [5, 2, 8, 3, 7];
+    console.log(loadBalance(requests, 3)); // [12, 8, 5]
 ```
-#### conventional operation TS
 
+### Use Heap to schedule tasks
 ```typescript
-const minNumHeap = new MinHeap<number>([1, 6, 2, 0, 5]);
-minNumHeap.add(9);
-minNumHeap.has(1)        //  true
-minNumHeap.has(2)        //  true
-minNumHeap.poll()        //  0
-minNumHeap.poll()        //  1
-minNumHeap.peek()        //  2
-minNumHeap.has(1);       // false
-minNumHeap.has(2);       // true
-
-const arrFromHeap = minNumHeap.toArray();
-arrFromHeap.length       //  4
-arrFromHeap[0]           //  2
-arrFromHeap[1]           //  5
-arrFromHeap[2]           //  9
-arrFromHeap[3]           //  6
-minNumHeap.sort()        //  [2, 5, 6, 9]
-
-const maxHeap = new MaxHeap<{ keyA: string }>([], {comparator: (a, b) => b.keyA - a.keyA});
-const obj1 = {keyA: 'a1'}, obj6 = {keyA: 'a6'}, obj5 = {keyA: 'a5'}, obj2 = {keyA: 'a2'},
-    obj0 = {keyA: 'a0'}, obj9 = {keyA: 'a9'};
-
-maxHeap.add(obj1);
-maxHeap.has(obj1)                       // true
-maxHeap.has(obj9)                       // false
-maxHeap.add(obj6);
-maxHeap.has(obj6)                       // true
-maxHeap.add(obj5);
-maxHeap.add(obj2);
-maxHeap.add(obj0);
-maxHeap.add(obj9);
-maxHeap.has(obj9)                       // true
-
-const peek9 = maxHeap.peek();
-console.log(peek9.keyA)                 // 'a9'
-
-const heapToArr = maxHeap.toArray();
-console.log(heapToArr.map(ele => ele?.keyA));  // ['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();
-    console.log(polled.keyA)           // values[i]
-    i++;
-}
-```
+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;
+    }
 
-#### conventional operation JS
-
-```javascript
-const {MinHeap, MaxHeap} = require('data-structure-typed');
-// /* or if you prefer */ const {MinHeap, MaxHeap} = require('heap-typed');
-
-const minNumHeap = new MinHeap([1, 6, 2, 0, 5]);
-minNumHeap.add(9);
-minNumHeap.has(1)        //  true
-minNumHeap.has(2)        //  true
-minNumHeap.poll()        //  0
-minNumHeap.poll()        //  1
-minNumHeap.peek()        //  2
-minNumHeap.has(1);       // false
-minNumHeap.has(2);       // true
-
-const arrFromHeap = minNumHeap.toArray();
-arrFromHeap.length       //  4
-arrFromHeap[0]           //  2
-arrFromHeap[1]           //  5
-arrFromHeap[2]           //  9
-arrFromHeap[3]           //  6
-minNumHeap.sort()        //  [2, 5, 6, 9]
-
-const maxHeap = new MaxHeap([], {comparator: (a, b) => b.keyA - a.keyA});
-const obj1 = {keyA: 'a1'}, obj6 = {keyA: 'a6'}, obj5 = {keyA: 'a5'}, obj2 = {keyA: 'a2'},
-    obj0 = {keyA: 'a0'}, obj9 = {keyA: 'a9'};
-
-maxHeap.add(obj1);
-maxHeap.has(obj1)                       // true
-maxHeap.has(obj9)                       // false
-maxHeap.add(obj6);
-maxHeap.has(obj6)                       // true
-maxHeap.add(obj5);
-maxHeap.add(obj2);
-maxHeap.add(obj0);
-maxHeap.add(obj9);
-maxHeap.has(obj9)                       // true
-
-const peek9 = maxHeap.peek();
-console.log(peek9.keyA)             // 'a9'
-
-const heapToArr = maxHeap.toArray();
-console.log(heapToArr.map(ele => ele?.keyA));  // ['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();
-    console.log(polled.keyA)           // values[i]
-    i++;
-}
+    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]
+    ]);
+    console.log(scheduleTasks(tasks, 2)); // expectedMap
 ```
 
+[//]: # (No deletion!!! End of Example Replace Section)
+
+
 
 ## API docs & Examples
 

package/dist/data-structures/linked-list/doubly-linked-list.d.ts

@@ -709,22 +709,18 @@ export declare class DoublyLinkedList<E = any, R = any> extends IterableElementB
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The indexOf function in TypeScript returns the index of a specified element or node in a Doubly
-     * Linked List.
-     * @param {E | DoublyLinkedListNode<E>} elementOrNode - The `elementOrNode` parameter in the
-     * `indexOf` method can be either an element of type `E` or a `DoublyLinkedListNode` containing an
-     * element of type `E`.
-     * @returns The `indexOf` method is returning the index of the element or node in the doubly linked
-     * list. If the element or node is found in the list, the method returns the index of that element or
-     * node. If the element or node is not found in the list, the method returns -1.
+     * This function finds the index of a specified element, node, or predicate in a doubly linked list.
+     * @param {E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
+     * elementNodeOrPredicate - The `indexOf` method takes in a parameter `elementNodeOrPredicate`, which
+     * can be one of the following:
+     * @returns The `indexOf` method returns the index of the element in the doubly linked list that
+     * matches the provided element, node, or predicate. If no match is found, it returns -1.
      */
-    indexOf(elementOrNode: E | DoublyLinkedListNode<E>): number;
+    indexOf(elementNodeOrPredicate: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)): number;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     */
-    /**
      * This function retrieves an element from a doubly linked list based on a given element
      * node or predicate.
      * @param {E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
@@ -820,6 +816,12 @@ export declare class DoublyLinkedList<E = any, R = any> extends IterableElementB
      * @returns a new instance of the `DoublyLinkedList` class with elements of type `T` and `RR`.
      */
     map<EM, RM>(callback: ElementCallback<E, R, EM, DoublyLinkedList<E, R>>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): DoublyLinkedList<EM, RM>;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     */
+    countOccurrences(elementOrNode: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)): number;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

package/dist/data-structures/linked-list/doubly-linked-list.js

@@ -784,13 +784,7 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * node was not found.
      */
     addBefore(existingElementOrNode, newElementOrNode) {
-        let existingNode;
-        if (existingElementOrNode instanceof DoublyLinkedListNode) {
-            existingNode = existingElementOrNode;
-        }
-        else {
-            existingNode = this.getNode(existingElementOrNode);
-        }
+        const existingNode = this.getNode(existingElementOrNode);
         if (existingNode) {
             const newNode = this._ensureNode(newElementOrNode);
             newNode.prev = existingNode.prev;
@@ -824,13 +818,7 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * was not found in the linked list.
      */
     addAfter(existingElementOrNode, newElementOrNode) {
-        let existingNode;
-        if (existingElementOrNode instanceof DoublyLinkedListNode) {
-            existingNode = existingElementOrNode;
-        }
-        else {
-            existingNode = this.getNode(existingElementOrNode);
-        }
+        const existingNode = this.getNode(existingElementOrNode);
         if (existingNode) {
             const newNode = this._ensureNode(newElementOrNode);
             newNode.next = existingNode.next;
@@ -936,17 +924,15 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The indexOf function in TypeScript returns the index of a specified element or node in a Doubly
-     * Linked List.
-     * @param {E | DoublyLinkedListNode<E>} elementOrNode - The `elementOrNode` parameter in the
-     * `indexOf` method can be either an element of type `E` or a `DoublyLinkedListNode` containing an
-     * element of type `E`.
-     * @returns The `indexOf` method is returning the index of the element or node in the doubly linked
-     * list. If the element or node is found in the list, the method returns the index of that element or
-     * node. If the element or node is not found in the list, the method returns -1.
+     * This function finds the index of a specified element, node, or predicate in a doubly linked list.
+     * @param {E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
+     * elementNodeOrPredicate - The `indexOf` method takes in a parameter `elementNodeOrPredicate`, which
+     * can be one of the following:
+     * @returns The `indexOf` method returns the index of the element in the doubly linked list that
+     * matches the provided element, node, or predicate. If no match is found, it returns -1.
      */
-    indexOf(elementOrNode) {
-        const predicate = this._ensurePredicate(elementOrNode);
+    indexOf(elementNodeOrPredicate) {
+        const predicate = this._ensurePredicate(elementNodeOrPredicate);
         let index = 0;
         let current = this.head;
         while (current) {
@@ -962,8 +948,6 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     */
-    /**
      * This function retrieves an element from a doubly linked list based on a given element
      * node or predicate.
      * @param {E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
@@ -1122,6 +1106,23 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         }
         return mappedList;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     */
+    countOccurrences(elementOrNode) {
+        const predicate = this._ensurePredicate(elementOrNode);
+        let count = 0;
+        let current = this.head;
+        while (current) {
+            if (predicate(current)) {
+                count++;
+            }
+            current = current.next;
+        }
+        return count;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)