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].

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.

Basic Implementation

basic.go
Replay: real traced execution (multi-file project)
package main

import "fmt"

func main() {
	arr := []int{5, 1, 4, 2, 8}
	n := len(arr)
	for i := 0; i < n-1; i++ {
		swapped := false
		for j := 0; j < n-i-1; j++ {
			if arr[j] > arr[j+1] {
				arr[j], arr[j+1] = arr[j+1], arr[j]
				swapped = true
			}
		}
		if !swapped {
			break
		}
	}
	fmt.Println(arr)
}

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

    5func main() {6	arr := []int{5, 1, 4, 2, 8}7	n := len(arr)
    values this step[5, 1, 4, 2, 8]arr

  2. n ← 5

    6arr := []int{5, 1, 4, 2, 8}7n := len(arr)8for i := 0; i < n-1; i++ {
    values this step5n[5, 1, 4, 2, 8]arr

  3. swapped ← false

    8for i := 0; i < n-1; i++ {9	swapped := false10	for j := 0; j < n-i-1; j++ {
    values this stepfalseswapped

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

    10for j := 0; j < n-i-1; j++ {11	if arr[j] > arr[j+1] {12		arr[j], arr[j+1] = arr[j+1], 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

    11if arr[j] > arr[j+1] {12	arr[j], arr[j+1] = arr[j+1], arr[j]13	swapped = true
    values this step[5, 1, 4, 2, 8] → [1, 5, 4, 2, 8]arrtrueswapped

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

    10for j := 0; j < n-i-1; j++ {11	if arr[j] > arr[j+1] {12		arr[j], arr[j+1] = arr[j+1], 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

    11if arr[j] > arr[j+1] {12	arr[j], arr[j+1] = arr[j+1], arr[j]13	swapped = true
    values this step[1, 5, 4, 2, 8] → [1, 4, 5, 2, 8]arrtrueswapped

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

    10for j := 0; j < n-i-1; j++ {11	if arr[j] > arr[j+1] {12		arr[j], arr[j+1] = arr[j+1], 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

    11if arr[j] > arr[j+1] {12	arr[j], arr[j+1] = arr[j+1], arr[j]13	swapped = true
    values this step[1, 4, 5, 2, 8] → [1, 4, 2, 5, 8]arrtrueswapped

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

    10for j := 0; j < n-i-1; j++ {11	if arr[j] > arr[j+1] {12		arr[j], arr[j+1] = arr[j+1], arr[j]
    values this stepfalsearr[j] > arr[j+1][1, 4, 2, 5, 8]arr3j5arr[j]8arr[j+1]

  11. swapped ← false

    8for i := 0; i < n-1; i++ {9	swapped := false10	for j := 0; j < n-i-1; j++ {
    values this stepfalseswapped

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

    10for j := 0; j < n-i-1; j++ {11	if arr[j] > arr[j+1] {12		arr[j], arr[j+1] = arr[j+1], 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

    10for j := 0; j < n-i-1; j++ {11	if arr[j] > arr[j+1] {12		arr[j], arr[j+1] = arr[j+1], 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

    11if arr[j] > arr[j+1] {12	arr[j], arr[j+1] = arr[j+1], arr[j]13	swapped = true
    values this step[1, 4, 2, 5, 8] → [1, 2, 4, 5, 8]arrtrueswapped

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

    10for j := 0; j < n-i-1; j++ {11	if arr[j] > arr[j+1] {12		arr[j], arr[j+1] = arr[j+1], arr[j]
    values this stepfalsearr[j] > arr[j+1][1, 2, 4, 5, 8]arr2j4arr[j]5arr[j+1]

  16. swapped ← false

    8for i := 0; i < n-1; i++ {9	swapped := false10	for j := 0; j < n-i-1; j++ {
    values this stepfalseswapped

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

    10for j := 0; j < n-i-1; j++ {11	if arr[j] > arr[j+1] {12		arr[j], arr[j+1] = arr[j+1], 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

    10for j := 0; j < n-i-1; j++ {11	if arr[j] > arr[j+1] {12		arr[j], arr[j+1] = arr[j+1], arr[j]
    values this stepfalsearr[j] > arr[j+1][1, 2, 4, 5, 8]arr1j2arr[j]4arr[j+1]

  19. loop ← break

    16if !swapped {17	break18}
    values this stepbreakloopfalseswapped

  20. stdout ← [1 2 4 5 8]

    19	}20	fmt.Println(arr)21}
    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 (already sorted with early exit)
  • Space: O(1)
  • Stable: yes

Implementation notes

  • Go: nested for loops with the early-exit swapped flag. Go's standard sort.Ints would hide the comparison-and-swap the lesson is teaching.
  • The tuple swap arr[j], arr[j+1] = arr[j+1], arr[j] keeps the swap step visible without leaning on a helper.
  • 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.