Part VIII — Sorting Algorithms - cracking the tech interview system design and algorithms in java 25 • Dev|Journal

Why Sorting Matters

Sorting sits at the heart of computer science — and at the heart of technical interviews. You will encounter sorting in nearly every coding round, either directly (“sort this array by X”) or indirectly as a prerequisite step for another algorithm. Understanding sorting unlocks powerful techniques across the entire problem-solving spectrum.

Sorting enables:

Binary search: Searching a sorted array takes O(log n) instead of O(n). Without sorting, binary search doesn’t work.
Merging: Combining two sorted sequences runs in O(n) with two pointers. Merging unsorted data requires O(n²).
Deduplication: Finding and removing duplicates from a sorted array runs in O(n) with a single pass. An unsorted array demands a hash set or O(n²) nested comparison.
Greedy algorithms: Problems like interval scheduling, activity selection, and meeting rooms depend on sorting by start or end time.
Two-pointer techniques: Pair-sum, three-sum, and sliding window problems frequently require sorted input.
Order statistics: Finding the kth smallest or largest element becomes trivial after sorting.

Sorting transforms hard problems into tractable ones. When you hit a wall during an interview, ask yourself: “Would sorting the input help?” The answer is often yes.

The Comparison-Based Lower Bound: Ω(n log n)

Every comparison-based sorting algorithm — one that determines order by comparing pairs of elements — faces a fundamental speed limit: Ω(n log n) comparisons in the worst case.

The argument comes from decision trees. A comparison-based sort on n elements produces one of n! possible permutations. Each comparison is a binary decision (≤ or >), so the algorithm traces a path through a binary decision tree. A binary tree with L leaves has height at least log₂(L). Since the tree needs at least n! leaves (one per permutation):

$$\text{height} \geq \log_2(n!) = \Theta(n \log n)$$

This uses Stirling’s approximation: $\log_2(n!) \approx n \log_2 n - n \log_2 e$.

What this means for you: algorithms like merge sort and heap sort achieve O(n log n) worst case and are therefore asymptotically optimal among comparison-based sorts. You cannot do better with comparisons alone. Non-comparison sorts (counting sort, radix sort, bucket sort) bypass this bound by exploiting properties of the data — but they come with constraints on input types.

Stability: Preserving Relative Order

A sorting algorithm is stable if elements with equal keys maintain their original relative order after sorting.

Why does this matter? Consider sorting a list of employees first by department, then by salary:

Name	Department	Salary
Alice	Engineering	120K
Bob	Marketing	110K
Carol	Engineering	110K
Dave	Marketing	120K

If you sort by department first (alphabetically), then sort by salary with a stable sort, employees within the same salary bracket retain their department ordering. A non-stable sort could scramble that department ordering, undoing your first sort.

Stable sorts: merge sort, insertion sort, bubble sort, Tim sort. Non-stable sorts: quick sort, heap sort, selection sort.

Interview signal: Mentioning stability when discussing sort requirements demonstrates depth — interviewers notice it.

In-Place vs Extra Space

An in-place sorting algorithm uses O(1) extra memory beyond the input array (or O(log n) for recursion stacks). It rearranges elements within the original array.

An out-of-place algorithm requires additional memory proportional to the input size — typically O(n).

Property	In-Place Examples	Out-of-Place Examples
Memory	O(1) extra	O(n) extra
Algorithms	Quick sort, heap sort, insertion sort	Merge sort (standard), counting sort

In memory-constrained environments (embedded systems, processing massive datasets), in-place algorithms are essential. For general-purpose sorting where memory is abundant, the extra space trade-off often buys you stability or guaranteed O(n log n) performance.

Adaptive Sorting: Exploiting Pre-Sorted Data

An adaptive sorting algorithm runs faster when the input is already partially sorted. The algorithm detects existing order and reduces work accordingly.

Insertion sort: O(n) on already-sorted input — zero shifts needed per element.
Tim sort: Identifies natural runs (already-sorted subsequences) and merges them, achieving O(n) on fully sorted input.
Bubble sort with early termination: Detects a sorted array in a single pass.

Non-adaptive algorithms like selection sort, heap sort, and standard merge sort perform the same amount of work regardless of input order. They ignore any existing structure in the data.

Real-world data is rarely random. Log files arrive in timestamp order. Database results come pre-sorted by primary key. User lists maintain alphabetical grouping. Adaptive algorithms exploit this structure, and interviewers value candidates who recognize when adaptivity matters.

The Sorting Algorithm Comparison Table

Algorithm	Best	Average	Worst	Space	Stable?	In-Place?	Adaptive?
Bubble Sort	O(n)	O(n²)	O(n²)	O(1)	Yes	Yes	Yes
Selection Sort	O(n²)	O(n²)	O(n²)	O(1)	No	Yes	No
Insertion Sort	O(n)	O(n²)	O(n²)	O(1)	Yes	Yes	Yes
Quick Sort	O(n log n)	O(n log n)	O(n²)	O(log n)	No	Yes	No
Merge Sort	O(n log n)	O(n log n)	O(n log n)	O(n)	Yes	No	No
Heap Sort	O(n log n)	O(n log n)	O(n log n)	O(1)	No	Yes	No
Counting Sort	O(n + k)	O(n + k)	O(n + k)	O(k)	Yes	No	No
Radix Sort	O(d·n)	O(d·n)	O(d·n)	O(n + k)	Yes	No	No

k = range of input values; d = number of digits

Use this table as your decision framework during interviews:

Need guaranteed O(n log n)? → Merge sort or heap sort.
Need stability? → Merge sort or insertion sort (for small arrays).
Need in-place? → Quick sort or heap sort.
Nearly sorted data? → Insertion sort or Tim sort.
Small arrays (< 32 elements)? → Insertion sort.
Integer keys with bounded range? → Counting sort or radix sort.

What’s Ahead

Each sub-chapter dives deep into one sorting algorithm with full Java 25 implementations, visual walkthroughs, complexity proofs, and interview strategy:

Bubble Sort — The simplest swap-based sort, optimized with early termination.
Selection Sort — Find-minimum-and-swap with the minimum-swap property.
Insertion Sort — Build a sorted prefix, powering hybrid sorts like Tim sort.
Quick Sort — Partition schemes, pivot strategies, three-way partitioning, and quickselect.
Merge Sort — Divide-and-conquer with guaranteed O(n log n) and natural merge sort.
Heap Sort — Leverage the heap data structure for in-place O(n log n).
Counting Sort — Integer sorting that breaks the comparison-based lower bound.
Radix Sort — Digit-by-digit sorting for integers and strings.

Each chapter builds on this foundation. Master the properties here, and you will approach every sorting question with a clear framework for choosing the right tool.