Selection Sort Visualization — Step by Step

Two regions, one boundary

Picture the array split by an invisible line: everything left of the line is sorted and final, everything right of it is untouched. At the start, the line sits before index 0 — nothing is sorted yet. Each pass of Selection Sort does exactly one job: find the smallest value in the unsorted region and move it to the position just right of the line, then advance the line by one. After n−1 passes the line has swept the whole array and the sort is done. Unlike Bubble Sort, nothing left of the line is ever touched again.

Step 1: Scan for the minimum

Take [5, 2, 8, 1]. Pass one assumes the first unsorted element, 5, is the minimum, then scans right updating its guess: 2 is smaller (new minimum), 8 is not, 1 is smaller (new minimum). The scan always runs to the very end of the array — there is no way to know 1 is the true minimum without checking everything after it. That full scan happens every pass regardless of the data, which is why Selection Sort has no best case: even a sorted array costs the full n(n−1)/2 comparisons.

Step 2: One swap, one locked position

With the minimum found at index 3, Selection Sort makes a single swap: 5 and 1 trade places, giving [1, 2, 8, 5], and index 0 is locked forever. Pass two scans [2, 8, 5], finds 2 already in place, and — as in this implementation — skips the swap entirely when the minimum hasn't moved. Pass three scans [8, 5], swaps to [1, 2, 5, 8], and the last element is sorted by elimination. Total damage: at most n−1 swaps, the fewest of any comparison sort here.

Why so few writes — and why that matters

Selection Sort separates *finding* from *moving*. All the O(n²) work happens in comparisons, which are reads; each element is then written to its final home in one hop. Compare that with Bubble Sort, where a far-from-home element generates a long trail of swap writes. On hardware where writes are costly or physically limited — classic examples are EEPROM and flash memory — minimizing writes is the whole game, and this is the one niche where Selection Sort genuinely earns its keep.

The catch: instability

That long-distance swap has a side effect. Sort [3a, 3b, 1] (two equal 3s, tagged by original position): the minimum is 1, so it swaps with 3a — producing [1, 3b, 3a]. The equal elements have changed relative order, which makes Selection Sort unstable. If you are sorting records by one key while preserving an earlier ordering (say, sorting by grade while keeping names alphabetical), stability matters, and you should reach for Insertion Sort or Merge Sort instead.

JavaScript

function selectionSort(arr) {
  const n = arr.length;
  for (let i = 0; i < n - 1; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (arr[j] < arr[minIdx]) minIdx = j;
    }
    if (minIdx !== i) {
      [arr[i], arr[minIdx]] = [arr[minIdx], arr[i]];
    }
  }
  return arr;
}

Python

def selection_sort(arr):
    n = len(arr)
    for i in range(n - 1):
        min_idx = i
        for j in range(i + 1, n):
            if arr[j] < arr[min_idx]:
                min_idx = j
        if min_idx != i:  # at most one swap per pass
            arr[i], arr[min_idx] = arr[min_idx], arr[i]
    return arr

Java

public static void selectionSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIdx]) minIdx = j;
        }
        if (minIdx != i) { // at most one swap per pass
            int tmp = arr[i];
            arr[i] = arr[minIdx];
            arr[minIdx] = tmp;
        }
    }
}