Sorting

Bubble Sort

Repeatedly walk the array comparing adjacent pairs and swapping any that are out of order. After pass k, the k largest elements are in their final positions at the end. Stop early when a full pass makes zero swaps.

Algorithm

Canonical input [5, 1, 4, 2, 8] finishes after three passes: two with swaps, then a clean pass that triggers the early exit. Final array [1, 2, 4, 5, 8].

Basic Implementation

basic.cs 
using System;

class Program {
	static void Main() {
		int[] arr = new int[] { 5, 1, 4, 2, 8 };
		int n = arr.Length;
		for (int i = 0; i < n - 1; i++) {
			bool swapped = false;
			for (int j = 0; j < n - i - 1; j++) {
				if (arr[j] > arr[j + 1]) {
					int tmp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = tmp;
					swapped = true;
				}
			}
			if (!swapped) {
				break;
			}
		}
		Console.WriteLine("[" + string.Join(", ", arr) + "]");
	}
}

Complexity

  • Time: O(n^2) worst and average; O(n) best (already sorted with early exit)
  • Space: O(1)
  • Stable: yes

Implementation notes

  • C#: nested for loops with the early-exit swapped flag. Array.Sort(arr) would hide the comparison-and-swap the lesson is teaching.
  • The explicit int tmp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = tmp; three-line swap keeps the move visible without leaning on (arr[j], arr[j+1]) = (arr[j+1], arr[j]); tuple syntax.
  • The replay distinguishes compare frames from swap frames so the moving pivot value is visible. The pass number and swapped flag appear in the trace.
adjacent-pair compare and swap Inner loop walks `j` from `0` to `n - i - 2` comparing `arr[j]` and `arr[j + 1]`.
early exit A `swapped` flag set false at the start of each pass. If no swap happened, break out of the outer loop.