min_heap is a priority queue: it lets you read and remove its smallest entry quickly. Each entry is (count, value), so the smallest entry is the value with the smallest count. That entry sits at the root.

Take Top K Frequent Elements (LC 347) with nums = [1, 1, 1, 2, 3, 3, 3, 3, 3, 4, 4, 5, 5, 5, 5, 6] and k = 3. The counts are 1: 3, 2: 1, 3: 5, 4: 2, 5: 4 and 6: 1. The code pushes the six pairs in that order.

After the first three pushes, min_heap holds (3, 1), (1, 2) and (5, 3), and the root is (1, 2). Pushing (2, 4) makes four entries, which is more than k. The code pops the root (1, 2). Three entries remain, and they all have a bigger count than the entry that left.

Why this is correct: an evicted entry has a count no bigger than the k entries that stay in min_heap. So at least k values beat it, and it can never be one of the k most frequent. Later pushes only add more competitors, so the decision never needs to be undone.

The end of the example shows a useful case. The pair (1, 6) is pushed last, and it becomes the root at once. The next line pops it, so a new entry can be evicted in the same step it arrives. The final min_heap holds (3, 1), (4, 5) and (5, 3), so the answer is the values [1, 5, 3] in any order.

A binary heap is a list that is read as a tree. The entry at index i has its children at indexes 2 * i + 1 and 2 * i + 2, and its parent at index (i - 1) // 2. In a min-heap, every entry is no bigger than its two children. So the smallest entry is always at index 0, the root.

heappush adds the new entry at the end of the list. Then it swaps the entry with its parent while the entry is smaller than the parent. This is called sifting up, and it takes at most log2(len(min_heap)) swaps. heappop removes index 0, moves the last entry to index 0, and sifts it down. At each level, it swaps with the smaller child until the entry is no bigger than both children. This takes at most log2(len(min_heap)) levels too.

Example: push 5, 3, 8, 1, 2, 9, 4 one at a time into an empty list with heapq.heappush. The list becomes [1, 2, 4, 5, 3, 9, 8]. Index 1 holds 2, and its children at indexes 3 and 4 hold 5 and 3. Both are bigger, so the rule holds. heapq.heappop then returns 1, and the list becomes [2, 3, 4, 5, 8, 9].

heapq.heapify(items) turns a list that already exists into a heap in O(n) time, and it does not need n pushes. It sifts down every entry that has children, starting from index n // 2 - 1 and moving back to index 0. Half of the entries are leaves and need no work. Only one entry sits at the top level, and it may move down all the levels. The sum of all the moves is at most about n. In a test, heapify on 1000 distinct random numbers made 729 swaps, and on 100000 numbers it made 74427 swaps. Pushing 1000 numbers in descending order made 7987 swaps, because each new entry sifts all the way up.

Python's heapq is a min-heap only. For a max-heap, push the negated value and negate it again after each pop. Pushing -5, -3, -8, -1, -2, -9, -4 and popping three times gives 9, 8, 5 after negating. This card needs the min-heap itself: the root must be the entry to evict next.

There are three common ways to take the k biggest of n items. Sorting costs O(n log n). The Top-K Heap costs O(n log k), because each of the n pushes and pops works on a heap of at most k + 1 entries. Counting into buckets costs O(n) when the key is a count that can never be bigger than n.

A comparison count shows the difference. With n = 100000 distinct random numbers and k = 10, Python's sorted made about 1.53 million comparisons, and the push-then-pop loop of this card made about 0.70 million. The loop wins because a heap of 11 entries is only about 3 levels deep.

The same test with k = 1000 gives a different result. The heap loop made about 1.85 million comparisons, which is more than the sort. Big-O hides the constant: each pop compares up to two children per level, so the loop costs about 2 * log2(k) comparisons for a pop. Use the heap when k is much smaller than n, or when the data arrives as a stream and cannot be sorted at once.

For Top K Frequent Elements (LC 347), the key is a count, and a count is at most len(nums). So a list of buckets works: buckets[c] holds the values with count c. Then read the buckets from the largest count down until k values are collected. The code is counts = Counter(nums), then buckets = [[] for _ in range(len(nums) + 1)], then for value, count in counts.items(): buckets[count].append(value). It makes no comparison between two counts, and its time is O(n). On 3000 random inputs, the bucket version, a sort version and the heap version returned the same values.

The buckets need a small, known range of keys. They do not work for the k closest points or the k biggest sums, where the key can be any number. The heap works for any key you can compare, so it is the general choice. The tool card Quickselect finds one k-th value in O(n) on average when every value is in memory.

In Kth Largest Element in a Stream (LC 703), numbers arrive one at a time, and the k-th largest is asked after each one. The template keeps min_heap between calls: pass the same list each time. After each push and pop, min_heap[0] is the k-th largest number seen so far. With k = 3 and the numbers 4, 5, 8, 2, the root after the fourth number is 4.

The general keep_k pushes (key(item), next(_arrivals), item). The middle number is an arrival counter. When two items have the same key, Python compares the arrival numbers next, and they are never equal. So Python never has to compare the items themselves. This matters when the items are objects or lists that cannot be compared with <.

The k smallest keys need a max-heap, which in Python means negating the key: key=lambda item: -item. The root is then the biggest of the kept keys, which is the one to evict.