排序算法之PHP

于 2014-10-27 14:11:31 发布
阅读量555 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构 php 排序算法 文章标签： 排序算法 插入 选择 交换 归并 基数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/gphjl/article/details/40506883
本文深入探讨了多种经典的排序算法，包括插入排序、选择排序、交换排序、归并排序及基数排序等，详细介绍了每种算法的基本思想、实现原理及其应用场景。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

概述

排序有内部排序和外部排序，内部排序就是数据在内存中排序，而外部排序是因为数据量很大，在排序过程中需要访问外存。
这里我们只谈内部排序。


排序算法在很多领域都有相当重要的地位，尤其是在处理大数据方面，一个优秀的算法可以节省大量的资源。那么算法很多，选择如何使用一般需要考虑以下几点：
1.时间复杂度（最差，平均和最好性能），根据排序的大小（n）
   按数量级递增排序，常见的时间复杂度有：常数阶(O(1))，对数阶(O(logn))，线性阶(O(n))，线性对数阶(O(nlogn))，平方阶(O(n^2))，立方阶(O(n^3))...k次方阶(O(n^k))，指数阶(O(2^n))。
   随着n不断增大，上述时间复杂度不断增大，算法执行效率越低。
   一般而言，好的性能是O(nlogn)，差的性能是O(n^2)，理想的性能是O(n)。
2.空间复杂度
   指执行这个算法所需要的内存空间。
3.稳定性
   一个排序算法是稳定的，就是当有两个相等记录的关键字A和B，且在原来列表中A在B之前，在排序后A也在B之前。



下面就分析下各类算法的具体实现

1. 插入排序之直接插入排序
基本思想：
每次从无序表中取第一个元素，把它插入到有序表的合适位置，使有序表依旧有序。

算法实现（由小到大排序）：
<?php
function insertSort($datas) {
    $length = count($datas);
    for ($i = 1; $i < $length; $i++) {
        for ($j = 0; $j < $i; $j++) {
            if ($datas[$j] > $datas[$i]) {
                $temp = $datas[$j];
                $datas[$j] = $datas[$i];
                $datas[$i] = $temp;
            }
        }
    }
    return $datas;
}
$oldData = array(24, 99, -13, 145, 2, 13, 27);
$newData = insertSort($oldData);
print_r($newData);

2.插入排序之希尔排序
希尔排序又叫缩小增量排序
基本思想：
将整个待排元素序列分割成若干个子序列（由相隔某个‘增量’的元素组成）分别进行直接插入排序，然后依次缩减增量再进行排序，直至‘增量’变为1，即所有记录放在一个组里排序。
以n=9的一个数组24，99，-13，145，2，13，27，55，4为例：
第一次 增量（[n / 2]）为4
    24    99    -13    145    2    13    27    55    4
    A0                              A1                          A2
            B0                               B1
                     C0                             C1
                              D0                            D1
    A0，A1，B0，B1等为分组标记，大写字母相同表示在同组内，数字表示该组下标，每次对同一组进行直接插入排序。即分成了4组（24,2,4）（99,13）（-13,27）（145,55），排序后就变成（2,4,24）（13,99）（-13,27）（55,145），下同。
第二次 增量 为 2
  第一次排序后
    2    13    -13    55    4    99    27    145    24
   A0           A1            A2           A3              A4
          B0             B1          B2              B3  
第三次 增量 为1
  第二次排序后
    -13    13    2    55    4    99    24    145    27
    A0     A1   A2  A3   A4   A5    A6     A7    A8
    进行直接插入排序后得到数组：-13，2，4，13，24，27，55，99，145

算法实现（由小到大排序）：
<?php
function shellInsertSort($datas) {
    $length = count($datas);
    $increment = floor($length / 2);
    while (1 <= $increment) {
        for ($i = 0; $i < $increment; $i++) {
            for ($j = $i + $increment; $j < $length; $j += $increment) {
                for ($z = $i; $z < $j; $z += $increment) {
                    if ($datas[$z] > $datas[$j]) {
                        $temp = $datas[$z];
                        $datas[$z] = $datas[$j];
                        $datas[$j] = $temp;
                    }
                }
            }
        }
        $increment = floor($increment / 2);
    }
    return $datas;
}
$oldData = array(24, 99, -13, 145, 2, 13, 27, 55, 4);
$newData = shellInsertSort($oldData);
print_r($newData);

3.选择排序之简单（直接）选择排序
基本思想：
在待排序的一组数中，选择最小（最大）的数与第一个位置的数比较交换，然后在剩下的数中再找出最小（最大）的数与第二个位置的数比较交换，直到第n-1个数与第n个数比较交换。

算法实现（由小到大排序）：
<?php
function selectSort($datas) {
    $length = count($datas);
    for ($i = 0; $i < $length - 1; $i++) {
        $minIndex = $i;
        for ($j = $i + 1; $j < $length; $j++) {
            if ($datas[$minIndex] > $datas[$j]) {
                $minIndex = $j;
            }
        }
        if ($datas[$i] > $datas[$minIndex]) {
            $temp = $datas[$minIndex];
            $datas[$minIndex] = $datas[$i];
            $datas[$i] = $temp;
        }
    }
    return $datas;
}
$oldData = array(24, 99, -13, 145, 2, 13, 27, 55, 4);
$newData = selectSort($oldData);
print_r($newData);

4.选择排序之堆排序
基本思想：
堆是一种完全二叉树或者近似完全二叉树。
堆的定义如下：n个元素的序列（k1,k2,k3...kn），当且仅当满足
1. ki <= k(2i) 且 ki <= k(2i+1)    (1 <= i <= n/2)
    或者
2. ki >= k(2i) 且 ki >= k(2i+1)    (1 <= i <= n/2)
时称之为堆。ki相当于二叉树的非叶子结点，k(2i)是左子结点，k(2i+1)是右子结点。
由定义可以看出，1的每个结点都大于父结点，此称之为小根堆；反之2称之为大根堆。
24，99，-13，145，2，13，27，55，4
1.小根堆

存储结构：-13,2,4,13,24,27,55,99,145
2.大根堆

存储结构：145,99,55,27,24,13,4,2,-13

初始时把待排序的n个数看成是一棵顺序存储的二叉树，调整它们的存储顺序使之成为堆，将堆顶最大（最小）的数输出（即与第n个数交换位置），此时剩下n-1个数的堆被破坏，对n-1个数进行堆调整，输入堆顶最大（最小）的数，然后再对n-2个数进行堆调整并输出。依次类推，直到只有两个结点的堆，交换它们，最终得到n个有序序列，这个过程称为堆排序。
因此，实现堆排序需要解决两个问题；1.将n个待排序列初始化堆；2.将剩余n-1个数调整使其成为一个堆。
初始化堆事实上也是调整堆的过程，只不过初始化是对所有非叶子结点都进行调整。

初始化为大根堆的方法：
1）n个结点的完全二叉树，最后一个结点是第[n/2]个结点的子数；
2）从第[n/2]个结点为根的子树开始，使子树成为堆；
3）然后向前对各个结点为根的子树进行调整，使之成为堆，直到根结点。
如图初始化堆的过程：24，99，-13，145，2，13，27，55，4

调整n-1个数的方法：
1）有n个元素的大根堆，输出堆顶元素后（堆顶元素与第n个元素交换），剩下n-1个元素，堆被破坏；
2）将根结点与左右子树中较大的进行比较交换；
3）若与左子树交换：若左子树的堆被破坏，重复2）
4）若与右子树交换：若右子树的堆被破坏，重复2）
5）继续对不满足堆性质的子树进行交换，直到叶子结点，堆建成。
如图调整堆的过程：


算法实现（由小到大排序）：
<?php
/**
* 调整堆
* @param dArray是待调整的数组
* @param nodeIndex是待调整数组元素的位置
* @param length是数组长度
**/
function heapAdjust(&$dArray, $nodeIndex, $length) {
    $child = 2 * $nodeIndex + 1; // 左子树结点位置
    while ($child < $length) {
        if ($child + 1 < $length && $dArray[$child] < $dArray[$child + 1]) { // 找到左右子树中较大一个的位置
            $child++;
        }
        if ($dArray[$nodeIndex] < $dArray[$child]) {
            $temp = $dArray[$child];
            $dArray[$child] = $dArray[$nodeIndex];
            $dArray[$nodeIndex] = $temp;
        } else {
            break;        
        }
        $nodeIndex = $child;
        $child = 2 * $nodeIndex + 1;
    }
}

function heapSort($datas) {
    $length = count($datas);
    // 初始化堆
    for ($i = floor($length / 2); $i > 0; $i--) {
        heapAdjust($datas, $i - 1, $length);
    }
    for ($i = 0, $j = $length; $i < $length - 1; $i++) {
        // 输出堆顶元素
        if ($datas[0] > $datas[$j - 1]) {
            $temp = $datas[$j - 1];
            $datas[$j - 1] = $datas[0];
            $datas[0] = $temp;
        }
        $j--;
        // 对被破坏的堆进行调整
        heapAdjust($datas, 0, $j);
    }
    return $datas;
}
$oldData = array(24, 99, -13, 145, 2, 13, 27, 55, 4);
$newData = heapSort($oldData);
print_r($newData);

5.交换排序之冒泡排序
基本思想：
冒泡排序是非常容易理解和实现的，还是以从小到大排序为例：
1. 自上而下对相邻两个数进行比较和调整，较大的往下沉，较小的往上冒；
2. 这样对n个数遍历过一次后，最大的数就在第n的位置上；
3. 重复上述步骤直至排序完成。

算法实现（由小到大排序）：
<?php
function bubbleSort($datas) {
    $length = count($datas);
    for ($i = 0; $i < $length - 1; $i++) {
        for ($j = 0; $j < $length - 1 - $i; $j++) {
            if ($datas[$j] > $datas[$j + 1]) {
                $temp = $datas[$j + 1];
                $datas[$j + 1] = $datas[$j];
                $datas[$j] = $temp;            
            }        
        }
    }
    return $datas;
}
$oldData = array(24, 99, -13, 145, 2, 13, 27, 55, 4);
$newData = bubbleSort($oldData);
print_r($newData);

6.交换排序之快速排序
快速排序因为排序效率在几种同为O(nlogn)的几种排序方法中效率较高，所以经常被采用。
基本思想：
通过一趟排序将待排序的数据分割成独立的两部分，其中一部分数据都要比另一部分数据小，然后分别对两部分进行快速排序，以此达到整个数据变成有序序列。
1）选择一个基准元素，通常选第一个或最后一个；
2）通过一趟排序分割成两部分，其中一部分都比基准元素小，另一部分都比基准元素大；
3）接着用同样的方法分别对两部分进行排序，直至序列有序。
一趟排序的过程（如下是个待排序的数组a）：
下标012345678
数据2499-1314521327554
取第一个数为基准元素，初始时 i = 0，j = 8，key = a[0] = 24
现在目的就是要找到比24都小的数且放在24的左边，找到比24都大的数且放在24的右边，慢慢来，一个一个找，因为是以第一个元素作为基准元素，所以我们从最右边开始找。
可以这样理解，因为我们取走了a[0]位置上的数，现在需要找个数填补a[0]的位置，从右边开始找（j--）找到第一个小于24的数（是4），于是把4放在a[0]上，此时a[8]的位置又空缺出来，接着从左边开始找（i++）找到第一个大于24的数（是99），于是把99放在a[8]的位置上，数组变成：
下标012345678
数据424-13145213275599
此时 i = 1，j = 8，key = 24
重复上面的步骤，相当于a[1]位置空了，需要从右向左找，再从左向右找
下标012345678
数据413-13242145275599
此时 i = 3，j = 5， key = 24
接着填补a[3]的位置，找到了2（a[4]），此时j变成了4，接着填补a[4]的位置，发现 i = 4 = j，此时查找结束，将key(24)填回a[4]的位置，数组变成：
下标012345678
数据413-13224145275599
可以看出a[4]前面的数都小于它，a[4]后面的数都大于它，接着再分别对a[0...4]和a[5...8]这两个部分重复上述步骤即可。

对上述过程简单总结：
1）i = L，j = R，将基准数取出形成空缺a[i]；
2）j--由右向左找到第一个比它小的数，填回a[i]，形成空缺a[j]；
3）i++由左向右找到第一个比它大的数，填回a[j]；
4）重复2）3），直到i == j，将基准数填入a[i]。

算法实现（由小到大排序）：
<?php
// 不断挖坑填数
function quickAdjust(&$datas, $l, $r) {
    if ($l < $r) {
        $i = $l;
        $j = $r;
        $key = $datas[$i]; // 基准数
        while ($i < $j) {
            while ($i < $j && $key < $datas[$j]) {
                $j--;
            }
            if ($i < $j) {
                $datas[$i] = $datas[$j]; // 填补i上的位置，形成j位置的空缺
                $i++;
            }

            while ($i < $j && $datas[$i] < $key) {
                $i++;
            }
            if ($i < $j) {
                $datas[$j] = $datas[$i]; // 填补j上的位置，形成i位置的空缺
                $j--;
            }
        }
        $datas[$i] = $key; // 将基准书补回
        quickAdjust($datas, $l, $i - 1);
        quickAdjust($datas, $i + 1, $r);
    }
}
function quickSort($datas) {
    $length = count($datas);
    quickAdjust($datas, 0, $length - 1);
    return $datas;
}
$oldData = array(24, 99, -13, 145, 2, 13, 27, 55, 4);
$newData = quickSort($oldData);
print_r($newData);

7.归并排序
基本思想：
归并排序是将两个（或两个以上）的有序列合并成一个新的有序列。即把待排序列分成若干个有序的子序列，再把有序的子序列合并成整体有序序列。该算法是采用分治法的一个非常典型的应用。
归并，顾名思义，需要先归再并。我们先分别来分析。
首先考虑如何将两个有序列合并，这个比较简单：
假设a[i...n]有两个有序子列a[i...m]和a[m+1...n]，有个临时数组temp（刚开始为空）
1）i = i，j = m + 1，分别从子列的第一个数开始比较；
2）若 i > m 或 j > n，则转至步骤4）；
3）若 a[i] < a[j]，则将a[i]放入temp，i加1；转至步骤2）
     若 a[i] < a[j]，则将a[j]放入temp，j加1；转至步骤2）
4）此时至少一个子列已经处理完成，将另一个子列剩下的部分加入temp
     若 i < m，将 a[i...m]加入temp；若j < n，将 a[j...n]加入temp。
5）合并完成。

再考虑如何分成若干个有序子列：
1个元素总是有序的，所以对n个待排序列，每一个元素都可以看成有序的，再合并成相邻的两个小组就可以了，这样两两合并，直到生成有序序列。

算法实现（由小到大排序）：
<?php
// 将a[i...m]和a[m+1...n]合并成有序列
function merge(&$datas, $first, $mid, $last)
{
    $tempArray = array();
    $i = $first;
    $j = $mid + 1;
    $k = 0;
    while (($i <= $mid) && ($j <= $last)) {
        if ($datas[$i] < $datas[$j]) {
            $tempArray[] = $datas[$i];
            $i++;
            $k++;
        } else {
            $tempArray[] = $datas[$j];
            $j++;
            $k++;
        }
    }
    while ($i <= $mid) {
        $tempArray[] = $datas[$i];
        $i++;
        $k++;
    }
    while ($j <= $last) {
        $tempArray[] = $datas[$j];
        $j++;
        $k++;
    }
    for ($z = 0; $z < $k; $z++) {
        $datas[$first + $z] = $tempArray[$z];
    }
}

function mergeSort(&$datas, $first, $last)
{
    if ($first < $last) {
        $mid = floor(($first + $last) / 2);
        mergeSort($datas, $first, $mid);
        mergeSort($datas, $mid + 1, $last);
        merge($datas, $first, $mid, $last);
    }
}

function main($datas)
{
    $length = count($datas);
    mergeSort($datas, 0, $length - 1);
    return $datas;
}
$oldData = array(24, 99, -13, 145, 2, 13, 27, 55, 4);
$newData = main($oldData);
print_r($newData);

8.基数排序
基本思想：
将所有待比较的数值（正整数）统一为同样的位数长度（k1,k2...kn），位数较短的数前面补零，然后就有两种处理方法：
1）最高位优先法（MSD）：
      a. 先按k1排序分组，将序列分成若干个子序列，同一序列中，k1相等；
      b. 再对各组按k2排序分组，之后依次对后面的关键码继续这样的分组，直到按kn对各子组排序后；
      c. 再将各组连接起来，便得到一个有序序列。
2）最低位优先法（LSD）：
      a. 先对kn排序分组，按次序将各组连接起来；
      b. 再对kn-1排序分组，然后再连接起来，重复步骤直到k1；
      c. 将子组连接起来，便得到有序序列。
以LSD为例，有如下一串数值：
72，93，24，65，99，62，45，89，42
首先根据个位数进行分配：
0
1
2     72      62    42
3     93
4     24
5     65      45
6
7
8
9 99      89
把各组按次序收集起来：
72，62，42，93，24，65，45，99，89
再根据十位数进行分配：
0
1
2     24
3
4     42    45
5
6     62    65
7     72
8 89
9     93    99
再收集：
24，42，45，62，65，72，89，93，99
排序完成，变成有序序列。

算法实现（由小到大排序）：
<?php
// 找到number上n位的数字
function getDigit($number, $n)
{
    $temp = 1;
    for ($i = 0; $i < $n - 1; $i++) {
        $temp *= 10;    
    }
    return ($number / $temp) % 10;
}

// LSD法
function radixLSDSort($datas)
{
    $length = count($datas);
    $n = 1; // 从个位开始分配
    $flag = true;
    while ($flag) {
        $sumN = 0;
        $temp = array(); // 临时空间
        for ($i = 0; $i < $length; $i++) {
            $placeNum = getDigit($datas[$i], $n);
            $temp[$placeNum][] = $datas[$i];
            $sumN += $placeNum;
        }
        if (0 == $sumN) {
            $flag = false;
        } else {
            $datas = array();
            for ($j = 0; $j <= 9; $j++) { // 各组按次序收集起来
                isset($temp[$j]) && $datas = array_merge($datas, $temp[$j]);
            }
            $n++;
        }
        unset($temp);
    }
    return $datas;
}
$oldData = array(24, 99, 13, 145, 2, 13, 27, 55, 4);
$newData = radixLSDSort($oldData);
print_r($newData);

总结
每种算法的代码都可以深度挖掘，继续优化，但编程到了极致，核心就是思想，学习算法最重要的是开拓思路，转换思维。确保自己真正明白算法的思想，然后自己写出代码，才是真正掌握。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值