Sorting Algorithms Visualized

Sorting means arranging items in a specific order — usually smallest to largest (ascending) or largest to smallest (descending). It is one of the most fundamental operations in computer science.

Why does sorting matter?

• Searching sorted data is much faster (e.g., binary search)
• Sorted data is easier for humans to read and analyze
• Many algorithms require sorted input to work correctly

Time Complexity tells us how an algorithm's speed scales with input size n:

• O(n²) — Simple sorts (Bubble, Selection, Insertion). Fine for small datasets, but slow for large ones.
• O(n log n) — Advanced sorts (Merge Sort, Quick Sort). Much faster for large datasets.

Below, see the difference between an unsorted and sorted array visualized as bars:

Bubble Sort repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order. The largest unsorted element "bubbles up" to its correct position each pass.

for i = 0 to n-1:
  for j = 0 to n-i-2:
    if arr[j] > arr[j+1]:
      swap(arr[j], arr[j+1])

Time complexity: O(n²) average and worst case.

Selection Sort finds the minimum element from the unsorted portion and places it at the beginning. It divides the array into a sorted and unsorted region.

for i = 0 to n-1:
  minIdx = i
  for j = i+1 to n-1:
    if arr[j] < arr[minIdx]: minIdx = j
  swap(arr[i], arr[minIdx])

Insertion Sort builds the sorted array one element at a time by inserting each element into its correct position among the already-sorted elements.

for i = 1 to n-1:
  key = arr[i], j = i-1
  while j >= 0 and arr[j] > key:
    arr[j+1] = arr[j], j--
  arr[j+1] = key

Both are O(n²), but Insertion Sort often performs fewer comparisons on nearly-sorted data.

1. What is the time complexity of Bubble Sort in the worst case?

2. Which sorting algorithm "bubbles" the largest element to the end on each pass?

3. Which algorithm typically performs best on nearly-sorted data?