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. Early-exit when a pass makes zero swaps.

Algorithm

Canonical input from the lesson spec is [5, 1, 4, 2, 8]. Three passes sort the array; pass three triggers the early exit.

adjacent swap Swap neighbouring out-of-order pairs.
early termination A pass with zero swaps means the array is already sorted.

Basic Implementation

basic.dart
Replay: real traced execution (multi-file project)
void main() {
  final arr = <int>[5, 1, 4, 2, 8];
  final n = arr.length;
  for (var i = 0; i < n - 1; i++) {
    var swapped = false;
    for (var j = 0; j < n - i - 1; j++) {
      if (arr[j] > arr[j + 1]) {
        final tmp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = tmp;
        swapped = true;
      }
    }
    if (!swapped) {
      break;
    }
  }
  print(arr);
}

  1. arr ← [5, 1, 4, 2, 8]

    1void main() {2  final arr = <int>[5, 1, 4, 2, 8];3  final n = arr.length;
    values this step[5, 1, 4, 2, 8]arr

  2. n ← 5

    2final arr = <int>[5, 1, 4, 2, 8];3final n = arr.length;4for (var i = 0; i < n - 1; i++) {
    values this step5n[5, 1, 4, 2, 8]arr

  3. swapped ← false

    4for (var i = 0; i < n - 1; i++) {5  var swapped = false;6  for (var j = 0; j < n - i - 1; j++) {
    values this stepfalseswapped

  4. arr[j] > arr[j+1] ← true

    6for (var j = 0; j < n - i - 1; j++) {7  if (arr[j] > arr[j + 1]) {8    final tmp = arr[j];
    values this steptruearr[j] > arr[j+1][5, 1, 4, 2, 8]arr0j5arr[j]1arr[j+1]

  5. arr ← [1, 5, 4, 2, 8], swapped ← true

    9arr[j] = arr[j + 1];10arr[j + 1] = tmp;11swapped = true;
    values this step[5, 1, 4, 2, 8] → [1, 5, 4, 2, 8]arrtrueswapped

  6. arr[j] > arr[j+1] ← true

    6for (var j = 0; j < n - i - 1; j++) {7  if (arr[j] > arr[j + 1]) {8    final tmp = arr[j];
    values this steptruearr[j] > arr[j+1][1, 5, 4, 2, 8]arr1j5arr[j]4arr[j+1]

  7. arr ← [1, 4, 5, 2, 8], swapped ← true

    9arr[j] = arr[j + 1];10arr[j + 1] = tmp;11swapped = true;
    values this step[1, 5, 4, 2, 8] → [1, 4, 5, 2, 8]arrtrueswapped

  8. arr[j] > arr[j+1] ← true

    6for (var j = 0; j < n - i - 1; j++) {7  if (arr[j] > arr[j + 1]) {8    final tmp = arr[j];
    values this steptruearr[j] > arr[j+1][1, 4, 5, 2, 8]arr2j5arr[j]2arr[j+1]

  9. arr ← [1, 4, 2, 5, 8], swapped ← true

    9arr[j] = arr[j + 1];10arr[j + 1] = tmp;11swapped = true;
    values this step[1, 4, 5, 2, 8] → [1, 4, 2, 5, 8]arrtrueswapped

  10. arr[j] > arr[j+1] ← false

    6for (var j = 0; j < n - i - 1; j++) {7  if (arr[j] > arr[j + 1]) {8    final tmp = arr[j];
    values this stepfalsearr[j] > arr[j+1][1, 4, 2, 5, 8]arr3j5arr[j]8arr[j+1]

  11. swapped ← false

    4for (var i = 0; i < n - 1; i++) {5  var swapped = false;6  for (var j = 0; j < n - i - 1; j++) {
    values this stepfalseswapped

  12. arr[j] > arr[j+1] ← false

    6for (var j = 0; j < n - i - 1; j++) {7  if (arr[j] > arr[j + 1]) {8    final tmp = arr[j];
    values this stepfalsearr[j] > arr[j+1][1, 4, 2, 5, 8]arr0j1arr[j]4arr[j+1]

  13. arr[j] > arr[j+1] ← true

    6for (var j = 0; j < n - i - 1; j++) {7  if (arr[j] > arr[j + 1]) {8    final tmp = arr[j];
    values this steptruearr[j] > arr[j+1][1, 4, 2, 5, 8]arr1j4arr[j]2arr[j+1]

  14. arr ← [1, 2, 4, 5, 8], swapped ← true

    9arr[j] = arr[j + 1];10arr[j + 1] = tmp;11swapped = true;
    values this step[1, 4, 2, 5, 8] → [1, 2, 4, 5, 8]arrtrueswapped

  15. arr[j] > arr[j+1] ← false

    6for (var j = 0; j < n - i - 1; j++) {7  if (arr[j] > arr[j + 1]) {8    final tmp = arr[j];
    values this stepfalsearr[j] > arr[j+1][1, 2, 4, 5, 8]arr2j4arr[j]5arr[j+1]

  16. swapped ← false

    4for (var i = 0; i < n - 1; i++) {5  var swapped = false;6  for (var j = 0; j < n - i - 1; j++) {
    values this stepfalseswapped

  17. arr[j] > arr[j+1] ← false

    6for (var j = 0; j < n - i - 1; j++) {7  if (arr[j] > arr[j + 1]) {8    final tmp = arr[j];
    values this stepfalsearr[j] > arr[j+1][1, 2, 4, 5, 8]arr0j1arr[j]2arr[j+1]

  18. arr[j] > arr[j+1] ← false

    6for (var j = 0; j < n - i - 1; j++) {7  if (arr[j] > arr[j + 1]) {8    final tmp = arr[j];
    values this stepfalsearr[j] > arr[j+1][1, 2, 4, 5, 8]arr1j2arr[j]4arr[j+1]

  19. loop ← break

    14if (!swapped) {15  break;16}
    values this stepbreakloopfalseswapped

  20. stdout ← [1, 2, 4, 5, 8]

    17  }18  print(arr);19}
    values this step[1, 2, 4, 5, 8]stdout[1, 2, 4, 5, 8]arr

Complexity

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

Implementation notes

  • Dart: write the two explicit loops and the swapped flag. Do not call arr.sort(); it would hide the comparison-and-swap mechanics the lesson is teaching.
  • The replay shows the compared pair on each frame and the post-swap array, matching the lesson spec's per-pass tables.