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.pl 
use strict; use warnings;
my @arr = (5, 1, 4, 2, 8);
my $n = scalar @arr;
my $i = 0;
my $done = 0;
while ($i < $n - 1 && !$done) {
	my $swapped = 0;
	my $j = 0;
	while ($j < $n - $i - 1) {
		if ($arr[$j] > $arr[$j + 1]) {
			my $tmp = $arr[$j];
			$arr[$j] = $arr[$j + 1];
			$arr[$j + 1] = $tmp;
			$swapped = 1;
		}
		$j = $j + 1;
	}
	if (!$swapped) {
		$done = 1;
	}
	$i = $i + 1;
}
print "[" . join(", ", @arr) . "]\n";

Complexity

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

Implementation notes

  • Perl: explicit while loops with my $i, my $j, $done, and $swapped so the early-exit flow stays visible. The stdlib sort { $a <=> $b } @arr would hide the comparison-and-swap the lesson is teaching, and last inside a labeled block would obscure the $done flag.
  • The explicit my $tmp = $arr[$j]; $arr[$j] = $arr[$j+1]; $arr[$j+1] = $tmp three-line swap keeps the move visible without leaning on Perl's list-slice assignment @arr[$j, $j+1] = @arr[$j+1, $j].
  • 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 `0` at the start of each pass. If no swap happened, flip a `$done` flag and break out of the outer loop.