PHP Bubble Sort Algorithm
last modified April 16, 2025
Basic Definitions
An algorithm is a step-by-step procedure to solve a problem or perform a computation. In programming, algorithms are implemented as functions or methods.
Sorting is arranging data in a particular order, typically ascending or descending. Efficient sorting is crucial for optimizing other algorithms that require sorted input.
Common sorting algorithms include:
- Bubble Sort
- Quick Sort
- Merge Sort
- Insertion Sort
- Selection Sort
- Heap Sort
Bubble Sort Algorithm
Bubble Sort is a simple comparison-based algorithm. It repeatedly steps through the list, compares adjacent elements and swaps them if they are in the wrong order.
The algorithm gets its name because smaller elements "bubble" to the top of the list. It has O(n²) time complexity, making it inefficient for large datasets.
Basic Bubble Sort Implementation
Here's a basic implementation of Bubble Sort in PHP for numeric data:
<?php
function bubbleSort(array $arr): array {
$n = count($arr);
for ($i = 0; $i < $n - 1; $i++) {
for ($j = 0; $j < $n - $i - 1; $j++) {
if ($arr[$j] > $arr[$j + 1]) {
// Swap elements
$temp = $arr[$j];
$arr[$j] = $arr[$j + 1];
$arr[$j + 1] = $temp;
}
}
}
return $arr;
}
$numbers = [64, 34, 25, 12, 22, 11, 90];
$sorted = bubbleSort($numbers);
print_r($sorted);
// Output: Array ( [0] => 11 [1] => 12 [2] => 22 [3] => 25 [4] => 34 [5] => 64 [6] => 90 )
Optimized Bubble Sort
We can optimize Bubble Sort by adding a flag to check if any swaps were made in a pass. If no swaps occur, the array is already sorted.
<?php
function optimizedBubbleSort(array $arr): array {
$n = count($arr);
for ($i = 0; $i < $n - 1; $i++) {
$swapped = false;
for ($j = 0; $j < $n - $i - 1; $j++) {
if ($arr[$j] > $arr[$j + 1]) {
// Swap elements
$temp = $arr[$j];
$arr[$j] = $arr[$j + 1];
$arr[$j + 1] = $temp;
$swapped = true;
}
}
// If no swaps, array is sorted
if (!$swapped) break;
}
return $arr;
}
$numbers = [5, 1, 4, 2, 8];
$sorted = optimizedBubbleSort($numbers);
print_r($sorted);
// Output: Array ( [0] => 1 [1] => 2 [2] => 4 [3] => 5 [4] => 8 )
Sorting in Descending Order
To sort in descending order, we simply reverse the comparison condition.
<?php
function bubbleSortDesc(array $arr): array {
$n = count($arr);
for ($i = 0; $i < $n - 1; $i++) {
for ($j = 0; $j < $n - $i - 1; $j++) {
if ($arr[$j] < $arr[$j + 1]) { // Changed comparison operator
// Swap elements
$temp = $arr[$j];
$arr[$j] = $arr[$j + 1];
$arr[$j + 1] = $temp;
}
}
}
return $arr;
}
$numbers = [64, 34, 25, 12, 22, 11, 90];
$sorted = bubbleSortDesc($numbers);
print_r($sorted);
// Output: Array ( [0] => 90 [1] => 64 [2] => 34 [3] => 25 [4] => 22 [5] => 12 [6] => 11 )
Sorting Textual Data
Bubble Sort can also sort strings alphabetically by comparing them with the strcmp function.
<?php
function bubbleSortText(array $arr): array {
$n = count($arr);
for ($i = 0; $i < $n - 1; $i++) {
for ($j = 0; $j < $n - $i - 1; $j++) {
if (strcmp($arr[$j], $arr[$j + 1]) > 0) {
// Swap elements
$temp = $arr[$j];
$arr[$j] = $arr[$j + 1];
$arr[$j + 1] = $temp;
}
}
}
return $arr;
}
$names = ["John", "Alice", "Bob", "Eve", "David"];
$sorted = bubbleSortText($names);
print_r($sorted);
// Output: Array ( [0] => Alice [1] => Bob [2] => David [3] => Eve [4] => John )
Bubble Sort vs Quick Sort Benchmark
Let's compare Bubble Sort with the more efficient Quick Sort algorithm. We'll measure execution time for sorting large arrays.
<?php
function bubbleSort(array $arr): array {
$n = count($arr);
for ($i = 0; $i < $n - 1; $i++) {
for ($j = 0; $j < $n - $i - 1; $j++) {
if ($arr[$j] > $arr[$j + 1]) {
$temp = $arr[$j];
$arr[$j] = $arr[$j + 1];
$arr[$j + 1] = $temp;
}
}
}
return $arr;
}
function quickSort(array $arr): array {
if (count($arr) <= 1) return $arr;
$pivot = $arr[0];
$left = $right = [];
for ($i = 1; $i < count($arr); $i++) {
if ($arr[$i] < $pivot) {
$left[] = $arr[$i];
} else {
$right[] = $arr[$i];
}
}
return array_merge(quickSort($left), [$pivot], quickSort($right));
}
// Generate large array
$largeArray = range(1, 2000);
shuffle($largeArray);
// Benchmark Bubble Sort
$start = microtime(true);
bubbleSort($largeArray);
$bubbleTime = microtime(true) - $start;
// Benchmark Quick Sort
$start = microtime(true);
quickSort($largeArray);
$quickTime = microtime(true) - $start;
printf("Bubble Sort time: %.4f seconds\n", $bubbleTime);
printf("Quick Sort time: %.4f seconds\n", $quickTime);
// Typical output:
// Bubble Sort time: 1.2345 seconds
// Quick Sort time: 0.0123 seconds
The benchmark clearly shows Quick Sort's superior performance for large datasets. Bubble Sort's O(n²) complexity makes it impractical for large arrays, while Quick Sort's O(n log n) performs much better.
When to Use Bubble Sort
Despite its inefficiency, Bubble Sort has some use cases:
- Educational purposes to understand sorting algorithms
- When simplicity is more important than performance
- For nearly sorted data (with the optimized version)
- When working with very small datasets
Source
This tutorial covered the Bubble Sort algorithm in PHP with examples for both numeric and textual data, including performance comparisons.
Author
List all PHP tutorials.