当前位置：首页 > 文章列表 > 文章 > php教程 > PHP排序算法全解析：冒泡、快速与归并详解

PHP排序算法全解析：冒泡、快速与归并详解

2025-09-13 14:28:29 0浏览收藏

小伙伴们对文章编程感兴趣吗？是否正在学习相关知识点？如果是，那么本文《PHP多种排序算法实现详解》，就很适合你，本篇文章讲解的知识点主要包括。在之后的文章中也会多多分享相关知识点，希望对大家的知识积累有所帮助！

最直接高效的数据排序方式是使用PHP内置函数，如sort()、asort()、ksort()和usort()系列，它们性能优越且易于维护；对于简单数组用sort()或rsort()，关联数组根据键或值排序可选用ksort()或asort()，复杂结构则通过usort()结合自定义比较函数实现灵活排序；尽管可手动实现冒泡、快速排序等算法以理解原理或应对特殊需求，但生产环境推荐优先使用内置函数，因其经C语言优化，兼具高效性与稳定性，在大多数场景下能提供最佳平衡。

php如何实现排序_php多种排序算法实现

PHP中实现数据排序，最直接高效的方式是利用其丰富的内置函数，它们经过C语言优化，性能卓越。而对于更复杂的自定义逻辑或深入理解算法原理，我们也可以选择手动实现经典的排序算法。具体选择哪种，往往需要权衡性能、可维护性以及特定场景的需求。

PHP提供了一系列强大的内置函数来处理数组排序，这无疑是我们日常开发中最常用也最推荐的方式。当你需要对一个简单数组进行升序或降序排列时，sort() 和 rsort() 就能轻松搞定。它们会直接修改原数组，并将数组元素重新索引。

$numbers = [4, 2, 7, 1, 5];
sort($numbers);
print_r($numbers); // 输出: Array ( [0] => 1 [1] => 2 [2] => 4 [3] => 5 [4] => 7 )

对于关联数组，情况就变得稍微复杂一些。如果你希望根据值来排序，并且保留键与值之间的关联，那么 asort()（升序）和 arsort()（降序）是你的朋友。反之，若想根据键来排序，则使用 ksort()（升序）和 krsort()（降序）。

$fruits = ["d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple"];
asort($fruits); // 按值升序
print_r($fruits); // 输出: Array ( [c] => apple [b] => banana [d] => lemon [a] => orange )

ksort($fruits); // 按键升序
print_r($fruits); // 输出: Array ( [a] => orange [b] => banana [c] => apple [d] => lemon )

然而，当数据结构变得更复杂，比如一个包含对象或多维数组的数组，并且你需要根据某个特定属性或自定义规则进行排序时，usort()、uasort() 和 uksort() 就显得尤为重要了。它们允许你传入一个回调函数来定义比较逻辑，这赋予了排序极大的灵活性。

class Product {
    public $name;
    public $price;

    public function __construct($name, $price) {
        $this->name = $name;
        $this->price = $price;
    }
}

$products = [
    new Product("Laptop", 1200),
    new Product("Mouse", 25),
    new Product("Keyboard", 75),
    new Product("Monitor", 300)
];

// 使用 usort 根据产品价格进行升序排序
usort($products, function($a, $b) {
    if ($a->price == $b->price) {
        return 0;
    }
    return ($a->price < $b->price) ? -1 : 1;
});

foreach ($products as $product) {
    echo "Name: {$product->name}, Price: {$product->price}\n";
}
/*
输出:
Name: Mouse, Price: 25
Name: Keyboard, Price: 75
Name: Monitor, Price: 300
Name: Laptop, Price: 1200
*/

PHP内置排序函数：你真的都用对了吗？

很多时候，我发现不少开发者在PHP中处理排序时，往往只停留在 sort() 或 asort() 这样的基础函数上。这当然没有错，对于简单场景它们完全够用。但一旦遇到更复杂的数据结构，比如一个存储了用户信息的对象数组，需要根据用户的年龄、注册时间或者某种复合条件来排序时，如果还在尝试用 sort() 强行解决，那无疑是在给自己找麻烦。

usort()、uasort() 和 uksort() 才是真正的利器。它们的核心思想是“自定义比较”。你不需要关心排序算法的内部实现，只需要告诉PHP：给我两个元素，我来告诉你它们谁应该排在前面，谁在后面，或者它们是等价的。这个“告诉”的过程就是通过一个回调函数实现的。这个回调函数接收两个参数 $a 和 $b，分别代表数组中的两个待比较元素。它需要返回：

-1 (或任何负数) 如果 $a 应该排在 $b 之前。
1 (或任何正数) 如果 $a 应该排在 $b 之后。
0 如果 $a 和 $b 的顺序无关紧要（或者说它们是等价的）。

例如，我们有一个用户列表，每个用户是一个关联数组，包含 name 和 score。现在要根据 score 降序排列，如果 score 相同，则根据 name 升序排列。

$users = [
    ['name' => 'Alice', 'score' => 85],
    ['name' => 'Bob', 'score' => 92],
    ['name' => 'Charlie', 'score' => 85],
    ['name' => 'David', 'score' => 78],
];

uasort($users, function($userA, $userB) {
    // 首先按 score 降序
    if ($userA['score'] != $userB['score']) {
        return ($userA['score'] < $userB['score']) ? 1 : -1; // 注意这里是降序
    }
    // 如果 score 相同，则按 name 升序
    return ($userA['name'] < $userB['name']) ? -1 : 1;
});

print_r($users);
/*
输出:
Array
(
    [1] => Array ( [name] => Bob [score] => 92 )
    [0] => Array ( [name] => Alice [score] => 85 )
    [2] => Array ( [name] => Charlie [score] => 85 )
    [3] => Array ( [name] => David [score] => 78 )
)
*/

这里使用了 uasort() 而非 usort()，因为我们需要保持原有的键关联。如果你不需要保留键，usort() 同样适用。理解并熟练运用 usort() 系列函数，能让你在处理复杂排序需求时游刃有余，避免自己“造轮子”带来的潜在性能和维护问题。

手动实现经典排序算法：性能考量与代码实践

虽然PHP内置函数强大且高效，但在某些特定场景下，或者出于学习、面试准备的目的，手动实现一些经典的排序算法依然有其价值。它能帮助我们深入理解算法原理、时间复杂度、空间复杂度，以及在不同数据分布下的表现。坦白说，除了面试或者极度特殊的、需要微观控制的场景，我很少在生产环境手写这些基础排序，PHP底层C语言实现的优化程度远超一般手写PHP代码。

我们以最简单的冒泡排序（Bubble Sort）为例。它的核心思想是重复遍历数组，比较相邻的两个元素，如果它们的顺序不正确就交换它们，直到没有元素可以交换，即数组有序。

function bubbleSort(array $arr): array {
    $n = count($arr);
    for ($i = 0; $i < $n - 1; $i++) {
        // 标记是否发生交换，如果没有，说明数组已经有序
        $swapped = false;
        for ($j = 0; $j < $n - 1 - $i; $j++) {
            if ($arr[$j] > $arr[$j+1]) {
                // 交换元素
                $temp = $arr[$j];
                $arr[$j] = $arr[$j+1];
                $arr[$j+1] = $temp;
                $swapped = true;
            }
        }
        // 如果一轮遍历没有发生交换，说明数组已经有序，提前结束
        if (!$swapped) {
            break;
        }
    }
    return $arr;
}

$unsorted = [64, 34, 25, 12, 22, 11, 90];
$sorted = bubbleSort($unsorted);
print_r($sorted); // 输出: Array ( [0] => 11 [1] => 12 [2] => 22 [3] => 25 [4] => 34 [5] => 64 [6] => 90 )

冒泡排序的时间复杂度在最坏和平均情况下都是O(n^2)，对于大规模数据，它的效率非常低下。

再比如快速排序（Quick Sort），它通常被认为是效率较高的通用排序算法，平均时间复杂度为O(n log n)。其基本思想是：选择一个元素作为“基准”（pivot），然后将数组分为两部分，一部分所有元素都比基准小，另一部分所有元素都比基准大，然后对这两部分递归地进行快速排序。

实现快速排序会稍微复杂一些，涉及到递归和分区操作。这里我提供一个简化的快速排序PHP实现，帮助理解其核心逻辑：

function quickSort(array $arr): array {
    $len = count($arr);
    if ($len <= 1) {
        return $arr; // 递归结束条件
    }

    $pivot = $arr[0]; // 选择第一个元素作为基准
    $left = [];
    $right = [];

    for ($i = 1; $i < $len; $i++) {
        if ($arr[$i] < $pivot) {
            $left[] = $arr[$i];
        } else {
            $right[] = $arr[$i];
        }
    }

    // 递归排序左右两部分，并与基准合并
    return array_merge(quickSort($left), [$pivot], quickSort($right));
}

$unsorted = [64, 34, 25, 12, 22, 11, 90];
$sorted = quickSort($unsorted);
print_r($sorted); // 输出: Array ( [0] => 11 [1] => 12 [2] => 22 [3] => 25 [4] => 34 [5] => 64 [6] => 90 )

这个快速排序的实现虽然简洁，但它的基准选择和分区方式在最坏情况下（例如输入数组已经有序）可能退化到O(n^2)。更优的实现会选择随机基准或三数取中法，并进行原地分区，以减少内存消耗。

理解这些算法的运作方式，能够帮助你在遇到极端性能问题时，知道如何分析和优化，或者至少能让你在面试中不至于束手无策。但对于日常开发，我依然建议优先考虑PHP内置的排序函数，它们在性能和稳定性上通常更可靠。

排序算法的选择策略：什么时候该用什么？

选择合适的排序方法，并非一概而论，它是一个需要综合考量多个因素的决策过程。这就像你修车，螺丝刀和扳手都能拧螺丝，但哪种更合适，取决于螺丝的类型和拧紧的程度。

数据规模：
- 小规模数据（几百到几千个元素）： 性能差异不明显，内置函数是最佳选择，代码简洁、可读性高。即使是O(n^2)的算法，在小规模数据下也可能表现尚可。
- 大规模数据（数万到数百万个元素）： 性能变得至关重要。此时，O(n log n)的算法（如快速排序、归并排序）远优于O(n^2)的算法。PHP内置的 sort()、usort() 等函数通常采用高效的混合排序算法（如TimSort），所以它们依然是首选。如果你真的要手写，那必须选择高效的算法。
数据类型与复杂性：
- 简单数组（数值、字符串）： sort(), rsort() 足够。
- 关联数组（需要保留键值对）： asort(), arsort(), ksort(), krsort()。
- 复杂对象数组或多维数组（根据特定属性或逻辑排序）： usort(), uasort(), uksort() 配合自定义回调函数是唯一且最佳的选择。
稳定性要求：
- 什么是稳定性？ 如果数组中有两个或多个元素相等，稳定排序会保持它们在原数组中的相对顺序。例如，如果两个分数为85的学生，A在B之前，稳定排序后A依然在B之前。
- PHP的 sort() 和 usort() 通常是不稳定的（取决于内部实现，但不能保证）。如果你对稳定性有严格要求，可能需要自己实现一个稳定的排序算法（如归并排序），或者在 usort() 的回调函数中，当元素相等时返回 0，并确保比较逻辑能处理这种“等价”情况。
内存消耗：
- 某些排序算法，如归并排序，需要额外的O(n)空间来存储临时数组。而像快速排序的某些原地实现，空间复杂度可以达到O(log n)（递归栈）。在内存受限的环境下，这可能是需要考虑的因素。PHP内置函数通常会做优化，但如果数据量极其庞大，仍需警惕。
可读性与维护性：
- 毫无疑问，使用PHP内置函数能大大提高代码的可读性和可维护性。它们是标准库的一部分，行为明确，且经过充分测试。手写复杂排序算法，除非有非常特殊的理由，否则会增加代码的复杂度和潜在的bug风险。
实际性能测试：
- 理论分析很重要，但实际性能测试（Profiling）更重要。在面对真正需要优化的场景时，不要凭空猜测，使用 microtime(true) 或 Xdebug 等工具进行性能分析，找出瓶颈所在，然后有针对性地进行优化。有时候，排序甚至不是最好的解决方案，预先构建索引、使用哈希表进行查找，或者在数据存储层（数据库）进行排序，可能会更高效。