binary-tree-typed 2.4.4 → 2.5.0

package/src/data-structures/heap/heap.ts

@@ -8,6 +8,7 @@
 
 import type { Comparator, DFSOrderPattern, ElementCallback, HeapOptions } from '../../types';
 import { IterableElementBase } from '../base';
+import { ERR } from '../../common';
 
 /**
  * Binary heap with pluggable comparator; supports fast insertion and removal of the top element.
@@ -25,105 +26,6 @@ import { IterableElementBase } from '../base';
  * 7. Efficient Sorting Algorithms: For example, heap sort. Heap sort uses the properties of a heap to sort elements.
  * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prime's minimum-spanning tree algorithm, which use heaps to improve performance.
  * @example
- * // basic Heap creation and add operation
- *  // Create a min heap (default)
- *     const minHeap = new Heap([5, 3, 7, 1, 9, 2]);
- *
- *     // Verify size
- *     console.log(minHeap.size); // 6;
- *
- *     // Add new element
- *     minHeap.add(4);
- *     console.log(minHeap.size); // 7;
- *
- *     // Min heap property: smallest element at root
- *     const min = minHeap.peek();
- *     console.log(min); // 1;
- * @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
- *     });
- *
- *     console.log(maxHeap.size); // 3;
- *
- *     // Peek returns highest priority task
- *     const topTask = maxHeap.peek();
- *     console.log(topTask?.priority); // 8;
- *     console.log(topTask?.name); // 'Alert';
- * @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' });
- *
- *     console.log(eventHeap.size); // 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
- *     console.log(processedOrder[0].type); // 'critical';
- *     console.log(processedOrder[1].type); // 'critical';
- *     console.log(processedOrder[2].type); // 'warning';
- *     console.log(processedOrder[3].type); // 'info';
- *     console.log(processedOrder[4].type); // 'info';
- *
- *     // Verify O(log n) operations
- *     const newHeap = new Heap<number>([5, 3, 7, 1]);
- *
- *     // Add - O(log n)
- *     newHeap.add(2);
- *     console.log(newHeap.size); // 5;
- *
- *     // Poll - O(log n)
- *     const removed = newHeap.poll();
- *     console.log(removed); // 1;
- *
- *     // Peek - O(1)
- *     const top = newHeap.peek();
- *     console.log(top); // 2;
- * @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
@@ -238,6 +140,12 @@ import { IterableElementBase } from '../base';
  *       ['Task5', 4]
  *     ]);
  *     console.log(scheduleTasks(tasks, 2)); // expectedMap;
+ * @example
+ * // Get all elements as array
+ *  const heap = new Heap<number>([5, 1, 3, 2, 4]);
+ *     const arr = heap.toArray();
+ *     console.log(arr.length); // 5;
+ *     console.log(arr.sort()); // [1, 2, 3, 4, 5];
  */
 export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
   protected _equals: (a: E, b: E) => boolean = Object.is;
@@ -277,6 +185,26 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * Get the number of elements.
    * @remarks Time O(1), Space O(1)
    * @returns Heap size.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Track heap capacity
+ *  const heap = new Heap<number>();
+ *     console.log(heap.size); // 0;
+ *     heap.add(10);
+ *     heap.add(20);
+ *     console.log(heap.size); // 2;
+ *     heap.poll();
+ *     console.log(heap.size); // 1;
    */
 
   get size(): number {
@@ -331,6 +259,32 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * @remarks Time O(1) amortized, Space O(1)
    * @param element - Element to insert.
    * @returns True.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // basic Heap creation and add operation
+ *  // Create a min heap (default)
+ *     const minHeap = new Heap([5, 3, 7, 1, 9, 2]);
+ *
+ *     // Verify size
+ *     console.log(minHeap.size); // 6;
+ *
+ *     // Add new element
+ *     minHeap.add(4);
+ *     console.log(minHeap.size); // 7;
+ *
+ *     // Min heap property: smallest element at root
+ *     const min = minHeap.peek();
+ *     console.log(min); // 1;
    */
 
   add(element: E): boolean {
@@ -343,6 +297,20 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * @remarks Time O(N log N), Space O(1)
    * @param elements - Iterable of elements or raw values.
    * @returns Array of per-element success flags.
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Add multiple elements
+ *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
+ *     heap.addMany([5, 3, 7, 1]);
+ *     console.log(heap.peek()); // 1;
+ *     console.log(heap.size); // 4;
    */
 
   addMany(elements: Iterable<E | R>): boolean[] {
@@ -363,6 +331,42 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * Remove and return the top element.
    * @remarks Time O(log N), Space O(1)
    * @returns Top element or undefined.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @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
+ *     });
+ *
+ *     console.log(maxHeap.size); // 3;
+ *
+ *     // Peek returns highest priority task
+ *     const topTask = maxHeap.peek();
+ *     console.log(topTask?.priority); // 8;
+ *     console.log(topTask?.name); // 'Alert';
    */
 
   poll(): E | undefined {
@@ -380,6 +384,76 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * Get the current top element without removing it.
    * @remarks Time O(1), Space O(1)
    * @returns Top element or undefined.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @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' });
+ *
+ *     console.log(eventHeap.size); // 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
+ *     console.log(processedOrder[0].type); // 'critical';
+ *     console.log(processedOrder[1].type); // 'critical';
+ *     console.log(processedOrder[2].type); // 'warning';
+ *     console.log(processedOrder[3].type); // 'info';
+ *     console.log(processedOrder[4].type); // 'info';
+ *
+ *     // Verify O(log n) operations
+ *     const newHeap = new Heap<number>([5, 3, 7, 1]);
+ *
+ *     // Add - O(log n)
+ *     newHeap.add(2);
+ *     console.log(newHeap.size); // 5;
+ *
+ *     // Poll - O(log n)
+ *     const removed = newHeap.poll();
+ *     console.log(removed); // 1;
+ *
+ *     // Peek - O(1)
+ *     const top = newHeap.peek();
+ *     console.log(top); // 2;
    */
 
   peek(): E | undefined {
@@ -390,6 +464,21 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * Check whether the heap is empty.
    * @remarks Time O(1), Space O(1)
    * @returns True if size is 0.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Check if heap is empty
+ *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
+ *     console.log(heap.isEmpty()); // true;
+ *     heap.add(1);
+ *     console.log(heap.isEmpty()); // false;
    */
 
   isEmpty(): boolean {
@@ -400,6 +489,20 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * Remove all elements.
    * @remarks Time O(1), Space O(1)
    * @returns void
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Remove all elements
+ *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
+ *     heap.clear();
+ *     console.log(heap.isEmpty()); // true;
    */
 
   clear(): void {
@@ -423,6 +526,13 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * @remarks Time O(N), Space O(1)
    * @param element - Element to search for.
    * @returns True if found.
+   
+   
+    * @example
+ * // Check element existence
+ *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
+ *     console.log(heap.has(1)); // true;
+ *     console.log(heap.has(99)); // false;
    */
 
   override has(element: E): boolean {
@@ -435,6 +545,19 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * @remarks Time O(N), Space O(1)
    * @param element - Element to delete.
    * @returns True if an element was removed.
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Remove specific element
+ *  const heap = new Heap<number>([3, 1, 4, 1, 5], { comparator: (a, b) => a - b });
+ *     heap.delete(4);
+ *     console.log(heap.toArray().includes(4)); // false;
    */
 
   delete(element: E): boolean {
@@ -503,6 +626,13 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * @remarks Time O(N), Space O(H)
    * @param [order] - Traversal order: 'PRE' | 'IN' | 'POST'.
    * @returns Array of visited elements.
+   
+   
+    * @example
+ * // Depth-first traversal
+ *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
+ *     const result = heap.dfs('IN');
+ *     console.log(result.length); // 3;
    */
 
   dfs(order: DFSOrderPattern = 'PRE'): E[] {
@@ -548,6 +678,22 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * Return all elements in ascending order by repeatedly polling.
    * @remarks Time O(N log N), Space O(N)
    * @returns Sorted array of elements.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Sort elements using heap
+ *  const heap = new Heap<number>([5, 1, 3, 2, 4]);
+ *     const sorted = heap.sort();
+ *     console.log(sorted); // [1, 2, 3, 4, 5];
    */
 
   sort(): E[] {
@@ -565,6 +711,22 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * Deep clone this heap.
    * @remarks Time O(N), Space O(N)
    * @returns A new heap with the same elements.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Create independent copy
+ *  const heap = new Heap<number>([3, 1, 4], { comparator: (a, b) => a - b });
+ *     const copy = heap.clone();
+ *     copy.poll();
+ *     console.log(heap.size); // 3;
+ *     console.log(copy.size); // 2;
    */
 
   clone(): this {
@@ -579,6 +741,20 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * @param callback - Predicate (element, index, heap) → boolean to keep element.
    * @param [thisArg] - Value for `this` inside the callback.
    * @returns A new heap with the kept elements.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Filter elements
+ *  const heap = new Heap<number>([1, 2, 3, 4, 5], { comparator: (a, b) => a - b });
+ *     const evens = heap.filter(x => x % 2 === 0);
+ *     console.log(evens.size); // 2;
    */
 
   filter(callback: ElementCallback<E, R, boolean>, thisArg?: unknown): this {
@@ -603,6 +779,19 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * @param options - Options for the output heap, including comparator for EM.
    * @param [thisArg] - Value for `this` inside the callback.
    * @returns A new heap with mapped elements.
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Transform elements
+ *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
+ *     const doubled = heap.map(x => x * 2, { comparator: (a, b) => a - b });
+ *     console.log(doubled.peek()); // 2;
    */
 
   map<EM, RM>(
@@ -611,7 +800,7 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
     thisArg?: unknown
   ): Heap<EM, RM> {
     const { comparator, toElementFn, ...rest } = options ?? {};
-    if (!comparator) throw new TypeError('Heap.map requires options.comparator for EM');
+    if (!comparator) throw new TypeError(ERR.comparatorRequired('Heap.map'));
     const out = this._createLike<EM, RM>([], { ...rest, comparator, toElementFn });
     let i = 0;
     for (const x of this) {
@@ -641,7 +830,7 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
 
   protected readonly _DEFAULT_COMPARATOR: Comparator<E> = (a: E, b: E): number => {
     if (typeof a === 'object' || typeof b === 'object') {
-      throw TypeError('When comparing object types, define a custom comparator in options.');
+      throw new TypeError(ERR.comparatorRequired('Heap'));
     }
     if (a > b) return 1;
     if (a < b) return -1;
@@ -783,7 +972,7 @@ export class FibonacciHeap<E> {
   constructor(comparator?: Comparator<E>) {
     this.clear();
     this._comparator = comparator || this._defaultComparator;
-    if (typeof this.comparator !== 'function') throw new Error('FibonacciHeap: comparator must be a function.');
+    if (typeof this.comparator !== 'function') throw new TypeError(ERR.notAFunction('comparator', 'FibonacciHeap'));
   }
 
   protected _root?: FibonacciHeapNode<E>;

package/src/data-structures/heap/max-heap.ts

@@ -6,6 +6,7 @@
  */
 import type { HeapOptions } from '../../types';
 import { Heap } from './heap';
+import { ERR } from '../../common';
 
 /**
  * @template E
@@ -22,6 +23,52 @@ import { Heap } from './heap';
  * 7. Efficient Sorting Algorithms: For example, heap sort. Heap sort uses the properties of a heap to sort elements.
  * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum-spanning tree algorithm, which use heaps to improve performance.
  * @example
+ * // Find the K largest elements
+ *  const data = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5];
+ *     const heap = new MaxHeap(data);
+ *
+ *     // Extract top 3 elements
+ *     const top3 = [];
+ *     for (let i = 0; i < 3; i++) {
+ *       top3.push(heap.poll());
+ *     }
+ *     console.log(top3); // [9, 6, 5];
+ * @example
+ * // Priority-based task processing
+ *  interface Task {
+ *       name: string;
+ *       priority: number;
+ *     }
+ *
+ *     const heap = new MaxHeap<Task>([], {
+ *       comparator: (a, b) => b.priority - a.priority
+ *     });
+ *
+ *     heap.add({ name: 'Low priority', priority: 1 });
+ *     heap.add({ name: 'Critical fix', priority: 10 });
+ *     heap.add({ name: 'Medium task', priority: 5 });
+ *
+ *     // Highest priority first
+ *     console.log(heap.poll()?.name); // 'Critical fix';
+ *     console.log(heap.poll()?.name); // 'Medium task';
+ *     console.log(heap.poll()?.name); // 'Low priority';
+ * @example
+ * // Real-time top score tracking
+ *  const scores = new MaxHeap<number>();
+ *
+ *     // Stream of scores coming in
+ *     for (const score of [72, 85, 91, 68, 95, 78, 88]) {
+ *       scores.add(score);
+ *     }
+ *
+ *     // Current highest score without removing
+ *     console.log(scores.peek()); // 95;
+ *     console.log(scores.size); // 7;
+ *
+ *     // Remove top 2 scores
+ *     console.log(scores.poll()); // 95;
+ *     console.log(scores.poll()); // 91;
+ *     console.log(scores.peek()); // 88;
  */
 export class MaxHeap<E = any, R = any> extends Heap<E, R> {
   /**
@@ -33,9 +80,7 @@ export class MaxHeap<E = any, R = any> extends Heap<E, R> {
     super(elements, {
       comparator: (a: E, b: E): number => {
         if (typeof a === 'object' || typeof b === 'object') {
-          throw TypeError(
-            `When comparing object types, a custom comparator must be defined in the constructor's options parameter.`
-          );
+          throw new TypeError(ERR.comparatorRequired('MaxHeap'));
         }
         if (a < b) return 1;
         if (a > b) return -1;

package/src/data-structures/heap/min-heap.ts

@@ -23,6 +23,65 @@ import { Heap } from './heap';
  * 7. Efficient Sorting Algorithms: For example, heap sort. MinHeap sort uses the properties of a heap to sort elements.
  * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.
  * @example
+ * // Merge K sorted arrays
+ *  const arrays = [
+ *       [1, 4, 7],
+ *       [2, 5, 8],
+ *       [3, 6, 9]
+ *     ];
+ *
+ *     // Use min heap to merge: track (value, arrayIndex, elementIndex)
+ *     const heap = new MinHeap<[number, number, number]>([], {
+ *       comparator: (a, b) => a[0] - b[0]
+ *     });
+ *
+ *     // Initialize with first element of each array
+ *     arrays.forEach((arr, i) => heap.add([arr[0], i, 0]));
+ *
+ *     const merged: number[] = [];
+ *     while (heap.size > 0) {
+ *       const [val, arrIdx, elemIdx] = heap.poll()!;
+ *       merged.push(val);
+ *       if (elemIdx + 1 < arrays[arrIdx].length) {
+ *         heap.add([arrays[arrIdx][elemIdx + 1], arrIdx, elemIdx + 1]);
+ *       }
+ *     }
+ *
+ *     console.log(merged); // [1, 2, 3, 4, 5, 6, 7, 8, 9];
+ * @example
+ * // Dijkstra-style shortest distance tracking
+ *  // Simulating distance updates: (distance, nodeId)
+ *     const heap = new MinHeap<[number, string]>([], {
+ *       comparator: (a, b) => a[0] - b[0]
+ *     });
+ *
+ *     heap.add([0, 'start']);
+ *     heap.add([10, 'A']);
+ *     heap.add([5, 'B']);
+ *     heap.add([3, 'C']);
+ *
+ *     // Process nearest node first
+ *     console.log(heap.poll()); // [0, 'start'];
+ *     console.log(heap.poll()); // [3, 'C'];
+ *     console.log(heap.poll()); // [5, 'B'];
+ *     console.log(heap.poll()); // [10, 'A'];
+ * @example
+ * // Running median with min heap (upper half)
+ *  const upperHalf = new MinHeap<number>();
+ *
+ *     // Add larger numbers to min heap
+ *     for (const n of [5, 8, 3, 9, 1]) {
+ *       upperHalf.add(n);
+ *     }
+ *
+ *     // Smallest of the upper half is always accessible
+ *     console.log(upperHalf.peek()); // 1;
+ *     console.log(upperHalf.size); // 5;
+ *
+ *     // Remove smallest repeatedly
+ *     console.log(upperHalf.poll()); // 1;
+ *     console.log(upperHalf.poll()); // 3;
+ *     console.log(upperHalf.peek()); // 5;
  */
 export class MinHeap<E = any, R = any> extends Heap<E, R> {
   /**