Sorting & Searching

Build a max-heap, then repeatedly swap the root maximum to the end and sift down over the shrinking heap.

Repeatedly emit nodes with zero in-degree and decrement their neighbours; if you cannot emit all nodes, there is a cycle.

A stream is a lazy pipeline where intermediate steps like map and filter build the recipe and a terminal step like collect or count cooks the result.

A size-K min-heap holds the K largest so far; each add pushes then trims to K, and the root is the Kth largest.

Pick a pivot, partition smaller-left and larger-right, then recursively sort each side in place.

Split into halves until singletons, then merge sorted halves by always taking the smaller front element; always O(n log n) and stable.

Put the K list heads in a min-heap; repeatedly pop the smallest, append it, and push its next, giving a sorted merge in O(N log K).

Keep one candidate per list in a min-heap; poll the smallest, output it, and push that list's next element, for N log k total.

Sorting rearranges a collection into a defined order using a comparison rule.

Bubble sort repeatedly swaps adjacent out-of-order pairs so the largest value bubbles to the end each pass.

Selection sort repeatedly finds the smallest remaining element and swaps it into the next sorted position.

Insertion sort grows a sorted prefix by inserting each new element into its correct place, shifting bigger ones aside.

Low, mid, and high pointers partition the array into zeros, ones, and twos in a single pass with O(n) time and O(1) space.

Three pointers partition a 0/1/2 array in one pass: swap 0s to the front, 2s to the back, leave 1s in the middle.

Repeatedly take any node with no remaining prerequisites, output it, and relax its outgoing edges until all nodes are ordered or a cycle is detected.

Keep a max-heap of size K of the smallest numbers seen so far; its root is the Kth smallest.

Keep a min-heap of size K of the largest numbers; its root is always the Kth largest as the stream grows.

Pop the global minimum K times from a size-M min-heap; the Kth pop is the answer.

In one pass, copy intervals before the new one, merge all overlapping intervals with the new one, then copy intervals after.

When values are a permutation of 1 to n, the value itself tells you its home index, so one swap-until-correct pass sorts in linear time.

Three pointers, one pass: send lows to the front, highs to the back, and let middles settle in the middle.

Keep smallest tails; binary-search the slot; the tails array length is the LIS length.