Sorting Algorithms Explained: Visualization & Time Complexity

Sorting algorithms are the classic DSA topic: they appear in every exam, every interview prep list and every “learn to code” course. Sorting itself is easy to understand: put things in order. The magic is in how each algorithm does it, and why some are dramatically faster than others.

This guide explains the five sorting algorithms every student should know, with a live visualizer, a full time complexity table, merge sort code in Python, Java and C++, and a memory trick for all five.

Sorting algorithm visualizer

Pick an algorithm and press Play. Then try the same data with a different algorithm and compare the counters.

The 5 sorting algorithms explained

1. Bubble sort: biggest bubbles to the top

Walk through the array comparing neighbours and swap them if they're out of order. After each pass, the largest remaining value has “bubbled” to the end. Simple, but O(n²). With an early-exit check it's O(n) on already-sorted data.

2. Selection sort: the team captain

Like a captain picking players, scan the unsorted part, select the smallest, and swap it to the front. Always O(n²) comparisons, but it makes very few swaps.

3. Insertion sort: cards in your hand

Take the next item and insert it into its correct place among the already-sorted items to its left, exactly how you sort playing cards. O(n²) in general, but very fast for small or nearly sorted arrays.

4. Merge sort: split the deck, merge the piles

Split the array in half again and again until each piece has one item, then merge pieces back together in order. It takes log n levels of splitting with n work per level: O(n log n) every time. It's stable but needs O(n) extra memory.

5. Quick sort: the class monitor (pivot)

Pick a pivot, like a class monitor, and line everyone up: smaller values to its left, bigger to its right. The pivot is now in its final place; repeat on each side. O(n log n) on average and usually the fastest in practice, but O(n²) if the pivots are consistently bad (for example, always picking the last item of already-sorted data).

Time complexity of all sorting algorithms

Not sure what O(n²) and O(n log n) really mean? See Big O notation explained, which includes a growth graph.

Merge sort code (Python, Java, C++)

Merge sort is the most common “write a sorting algorithm” exam and interview question, because it shows recursion and divide and conquer clearly.

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])     # sort each half
    right = merge_sort(arr[mid:])
    return merge(left, right)        # then merge them

def merge(left, right):
    result, i, j = [], 0, 0
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:      # <= keeps it stable
            result.append(left[i]); i += 1
        else:
            result.append(right[j]); j += 1
    result.extend(left[i:])
    result.extend(right[j:])
    return result

print(merge_sort([38, 12, 55, 7, 44, 23]))  # [7, 12, 23, 38, 44, 55]

How to choose a sorting algorithm

• Small or nearly sorted data: insertion sort.
• Need guaranteed O(n log n) and stability: merge sort.
• Fast in-memory sorting on average: quick sort (with a good pivot choice).
• Little extra memory and guaranteed O(n log n): heap sort.
• Learning or teaching: bubble and selection sort, because they're easy to trace by hand.

What to learn next

Once data is sorted, you can search it in O(log n) with binary search. And for the two most common data structures in DSA, read stack vs queue.

Frequently asked questions