Top-K with a Heap - JavaScript DSA

Keep only the largest k values by maintaining a small min-heap.

Algorithm

Steps

Store the heap in an array.
Compare parent and child indexes instead of building explicit tree nodes.
Swap only when the heap order is violated.
Print the deterministic final heap state for replay comparison.

Complexity

Time: O(n log k)
Space: O(k)

bounded heap For top-k largest values, a min-heap of size k keeps the current cutoff at the root.

JavaScript DSA Implementation

basic.js

function listString(values) { return `[${values.join(", ")}]`; }
function heapInsert(heap, value) {
  heap.push(value);
  let child = heap.length - 1;
  while (child > 0) {
    const parent = Math.floor((child - 1) / 2);
    if (heap[parent] <= heap[child]) break;
    [heap[parent], heap[child]] = [heap[child], heap[parent]];
    child = parent;
  }
}
function heapPop(heap) {
  const smallest = heap[0];
  heap[0] = heap.pop();
  let parent = 0;
  while (true) {
    const left = parent * 2 + 1;
    const right = left + 1;
    if (left >= heap.length) break;
    let child = left;
    if (right < heap.length && heap[right] < heap[left]) child = right;
    if (heap[parent] <= heap[child]) break;
    [heap[parent], heap[child]] = [heap[child], heap[parent]];
    parent = child;
  }
  return smallest;
}
const values = [5, 1, 9, 3, 7, 2];
const heap = [];
for (const value of values) { heapInsert(heap, value); if (heap.length > 3) heapPop(heap); }
console.log(listString([...heap].sort((a, b) => b - a)));

Output

[9, 7, 5]

Implementation notes

The bounded heap is a mutable JavaScript Array of Number values using the standard binary-heap index layout. It keeps the smallest retained top-k value at index 0.
The loop inserts every value with heapInsert(heap, value). If heap.length > 3, it immediately calls heapPop(heap) to remove the current minimum and restore the size bound.
heapInsert uses push, Math.floor((child - 1) / 2), and numeric Number comparisons for sift-up. heapPop moves the last slot to the root, computes left and right child indexes, chooses the smaller child, and sifts down.
Swaps inside the heap helpers use destructuring assignment to mutate array slots in place. JavaScript specifies the temporary right-hand values; engines may optimize the short-lived storage used for the swap.
The replayed heap states after considering [5, 1, 9, 3, 7, 2] are [5], [1, 5], [1, 5, 9], [3, 5, 9], [5, 7, 9], and finally [5, 7, 9], showing 1, 3, and 2 trimmed as the heap exceeds size 3.
console.log(listString([...heap].sort((a, b) => b - a))) copies the heap before sorting for display, uses a numeric descending comparator, and prints [9, 7, 5]. Visible allocation is the input array, heap array, sorted copy, and strings created by join and template formatting.