The Top-k Template in Python, Java and TypeScript

import heapq


def top_k(values: list[int], k: int) -> list[int]:
    heap: list[int] = []
    for value in values:
        heapq.heappush(heap, value)
        if len(heap) > k:
            heapq.heappop(heap)
    return sorted(heap)


print("3 largest:", top_k([7, 2, 9, 4, 11, 5, 8], 3))
print("3 smallest:", sorted(-v for v in top_k([-v for v in [7, 2, 9, 4, 11, 5, 8]], 3)))

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.PriorityQueue;

public class TopK {
    static List<Integer> topK(int[] values, int k, Comparator<Integer> order) {
        PriorityQueue<Integer> heap = new PriorityQueue<>(order);
        for (int value : values) {
            heap.offer(value);
            if (heap.size() > k) {
                heap.poll();
            }
        }
        List<Integer> kept = new ArrayList<>();
        while (!heap.isEmpty()) {
            kept.add(heap.poll());
        }
        return kept;
    }

    public static void main(String[] args) {
        int[] values = {7, 2, 9, 4, 11, 5, 8};
        System.out.println("3 largest: " + topK(values, 3, Comparator.naturalOrder()));
        System.out.println("3 smallest: " + topK(values, 3, Comparator.reverseOrder()).reversed());
    }
}

class MinHeap<T> {
  private readonly items: T[] = [];
  private readonly before: (a: T, b: T) => boolean;

  constructor(before: (a: T, b: T) => boolean) {
    this.before = before;
  }

  get size(): number {
    return this.items.length;
  }

  push(value: T): void {
    const items = this.items;
    items.push(value);
    let i = items.length - 1;
    while (i > 0 && this.before(items[i], items[(i - 1) >> 1])) {
      [items[i], items[(i - 1) >> 1]] = [items[(i - 1) >> 1], items[i]];
      i = (i - 1) >> 1;
    }
  }

  pop(): T | undefined {
    const items = this.items;
    const top = items[0];
    const last = items.pop();
    if (items.length > 0 && last !== undefined) {
      items[0] = last;
      let i = 0;
      for (let child = 1; child < items.length; child = 2 * i + 1) {
        if (child + 1 < items.length && this.before(items[child + 1], items[child])) child++;
        if (!this.before(items[child], items[i])) break;
        [items[i], items[child]] = [items[child], items[i]];
        i = child;
      }
    }
    return top;
  }
}

function topK(values: number[], k: number): number[] {
  const heap = new MinHeap<number>((a, b) => a < b);
  for (const value of values) {
    heap.push(value);
    if (heap.size > k) {
      heap.pop();
    }
  }
  const kept: number[] = [];
  while (heap.size > 0) {
    kept.push(heap.pop() as number);
  }
  return kept;
}

console.log(`3 largest: [${topK([7, 2, 9, 4, 11, 5, 8], 3).join(", ")}]`);