排序算法

最新推荐文章于 2023-02-12 20:42:34 发布

php_elephant

最新推荐文章于 2023-02-12 20:42:34 发布

阅读量171

点赞数

分类专栏：算法

算法专栏收录该内容

2 篇文章 0 订阅

订阅专栏

排序算法

八大排序

插入排序:直接插入排序、希尔排序

交换排序:冒泡排序、快速排序

选择排序:简单选择排序、堆排序

归并排序

基数排序

1.插入排序—直接插入排序(Straight Insertion Sort)

基本思想:

将一个记录插入到已排序好的有序表中，从而得到一个新记录数增1的有序表。即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。

要点：设立哨兵，作为临时存储和判断数组边界之用。

直接插入排序示例：

如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。

算法的实现：

<?php

function insertSort($arr) {

//区分哪部分是已经排序好的

//哪部分是没有排序的

//找到其中一个需要排序的元素

//这个元素就是从第二个元素开始，到最后一个元素都是这个需要排序的元素

//利用循环就可以标志出来

//i循环控制每次需要插入的元素，一旦需要插入的元素控制好了，

//间接已经将数组分成了2部分，下标小于当前的（左边的），是排序好的序列

$len=count($arr);

for ($i=1; $i < $len; $i++) {

//获得当前需要比较的元素值。

$tmp = $arr[$i];

//内层循环控制比较并插入

for ($j = $i - 1; $j >= 0; $j--) {

//$arr[$i];//需要插入的元素; $arr[$j];//需要比较的元素

if ($tmp < $arr[$j]) {

//发现插入的元素要小，交换位置

//将后边的元素与前面的元素互换

$arr[$j + 1] = $arr[$j];

//将前面的数设置为当前需要交换的数

$arr[$j] = $tmp;

} else {

//如果碰到不需要移动的元素

//由于是已经排序好是数组，则前面的就不需要再次比较了。

break;

}

//将这个元素插入到已经排序好的序列内。

//返回

return $arr;

}

$arr = array(88, 1, 2, 5, 4, 3, 66, 0);

$res = insertSort($arr);

print_r($res);

效率：

时间复杂度：O（n^2）.

其他的插入排序有二分插入排序，2-路插入排序。

2. 插入排序—希尔排序（Shell`s Sort）

希尔排序是1959 年由D.L.Shell 提出来的，相对直接排序有较大的改进。希尔排序又叫缩小增量排序

基本思想：

插入排序的升级版（根据其特点：序列大部分已排好序时效率很高），将数据分为不同的组，先对每一组进行排序，然后对所有元素进行一次排序（即最后步长必须为1），步长的选择是递减的，比如5、3、1，现在一般使用D.E.Knuth分组方法（n很大是，用h(n+1)=3h(n)+1来分组，即1、4、13......）。

特点：平均时间复杂度O(n*logn)，最坏时间复杂度O(n^s)(1<s<2)，额外空间O(1)，不稳定排序（相等元素在不同组里，交换后相对顺序可能改变）

希尔排序的示例：

算法实现：

我们简单处理增量序列：增量序列d = {n/2 ,n/4, n/8 .....1} n为要排序数的个数

即：先将要排序的一组记录按某个增量d（n/2,n为要排序数的个数）分成若干组子序列，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。继续不断缩小增量直至为1，最后使用直接插入排序完成排序。

<?php

/**

* 希尔排序

function shell_sort(array $arr){

// 将$arr按升序排列

$len = count($arr);

$f = 3;// 定义因子

$h = 1;// 最小为1

while ($h < $len/$f){

$h = $f*$h + 1; // 1, 4, 13, 40, 121, 364, 1093, ...

}

while ($h >= 1){ // 将数组变为h有序

for ($i = $h; $i < $len; $i++){ // 将a[i]插入到a[i-h], a[i-2*h], a[i-3*h]... 之中（算法的关键

for ($j = $i; $j >= $h; $j -= $h){

if ($arr[$j] < $arr[$j-$h]){

$temp = $arr[$j];

$arr[$j] = $arr[$j-$h];

$arr[$j-$h] = $temp;

}

//print_r($arr);echo '<br/>'; // 打开这行注释，可以看到每一步被替换的情形

}

$h = intval($h/$f);

}

return $arr;

}

$arr = array(14, 9, 1, 4, 6, -3, 2, 99, 13, 20, 17, 15, 3);

$shell = shell_sort($arr);

echo '<pre>';

print_r($shell);

希尔排序时效分析很难，关键码的比较次数与记录移动次数依赖于增量因子序列f的选取，特定情况下可以准确估算出关键码的比较次数和记录的移动次数。目前还没有人给出选取最好的增量因子序列的方法。增量因子序列可以有各种取法，有取奇数的，也有取质数的，但需要注意：增量因子中除1 外没有公因子，且最后一个增量因子必须为1。希尔排序方法是一个不稳定的排序方法。

3. 交换排序—冒泡排序（Bubble Sort）

基本思想：

在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

原理：对一组数据，比较相邻数据的大小，将值小数据在前面，值大的数据放在后面。（以下都是升序排列，即从小到大排列）

　　举例说明： $arr = array(6, 3, 8, 2, 9, 1);

$arr 有6个数据，按照两两比较大小如下，注意比较轮数和每轮比较次数

　　第一轮排序：

　　　　第一次比较 6和3比较结果：3 6 8 2 9 1

　　　　第二次比较 6和3比较结果：3 6 8 2 9 1

　　　　第三次比较 8和2比较结果：3 6 2 8 9 1

　　　　第四次比较 8和9比较结果：3 6 2 8 9 1

　　　　第五次比较 9和1比较结果：3 6 2 8 1 9

　　第一轮比较总结：1.排序第1轮、比较5次，没有获得从小到大的排序 2.因为每次比较都是大数往后靠，所以比较完成后，可以确定大数排在最后（9 已经冒泡冒出来了，下轮比较可以不用比较了）

　　第二轮排序：

　　　　第一次比较 3和6比较结果：3 6 2 8 1 9

　　　　第二次比较 6和2比较结果：3 2 6 8 1 9

　　　　第三次比较 6和8比较结果：3 2 6 8 1 9

　　　　第四次比较 8和1比较结果：3 2 6 1 8 9

　　第二轮比较总结：1.排序第2轮、比较4次，没有获得从小到大的排序 2.冒泡出了 8，下轮不用比较8 了

　　第三轮排序：

　　　　第一次比较 3和2比较结果：2 3 6 1 8 9

　　　　第二次比较 3和6比较结果：2 3 6 1 8 9

　　　　第三次比较 6和1比较结果：2 3 1 6 8 9

　　第三轮比较总结：1.排序第3轮、比较3次，没有获得从小到大的排序 2.冒泡出了 6，下轮不用比较6 了

　　第四轮排序：

　　　　第一次比较 2和3比较结果：2 3 1 6 8 9

　　　　第二次比较 3和1比较结果：2 1 3 6 8 9

　　第四轮比较总结：1.排序第4轮、比较2次，没有获得从小到大的排序 2.冒泡出了 3，下轮不用比较3 了

　　第五轮排序：

　　　　第一次比较 2和1比较结果：1 2 3 6 8 9

　　第五轮比较总结：1.排序第5轮、比较1次，没有获得从小到大的排序 2.冒泡出了 2，由于还剩一个1，不用再比较了，至此通过5轮排序，完成整个排序。

　　通过以上五轮排序，若干次比较，我们有理由推断出一个结论：

　　对于一个长度为N的数组，我们需要排序 N-1 轮，每 i 轮要比较 N-i 次。对此我们可以用双重循环语句，外层循环控制循环轮次，内层循环控制每轮的比较次数。

算法的实现：

<?php

function order($arr){

$count = count($arr);

$temp = 0;

//外层控制排序轮次

for($i=0; $i<$count-1; $i++){

//内层控制每轮比较次数

for($j=0; $j< $count-1-$i; $j++){

if($arr[$j] > $arr[$j+1]){

$temp = $arr[$j];

$arr[$j] = $arr[$j+1];

$arr[$j+1] = $temp;

}

return $arr;

}

特点：平均时间复杂度O(n^2)，最坏时间复杂度O(n^2)，额外空间O(1)，稳定排序（因为比较和交换都是两相邻元素，相等时不交换），n较小时较好

4. 交换排序—快速排序（Quick Sort）

基本思想：

1）选择一个基准元素,通常选择第一个元素或者最后一个元素,

2）通过一趟排序将待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的元素值比基准值大。

3）此时基准元素在其排好序后的正确位置

4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。

快速排序的示例：

（a）一趟排序的过程：

（b）排序的全过程

算法的实现：

递归实现：

<?php

//快速排序

//待排序数组

$arr=array(6,3,8,6,4,2,9,5,1);

//函数实现快速排序

function quick_sort($arr)

{

//判断参数是否是一个数组

if(!is_array($arr)) return false;

//递归出口:数组长度为1，直接返回数组

$length=count($arr);

if($length<=1) return $arr;

//数组元素有多个,则定义两个空数组

$left=$right=array();

//使用for循环进行遍历，把第一个元素当做比较的对象

for($i=1;$i<$length;$i++)

{

//判断当前元素的大小

if($arr[$i]<$arr[0]){

$left[]=$arr[$i];

}else{

$right[]=$arr[$i];

}

//递归调用

$left=quick_sort($left);

$right=quick_sort($right);

//将所有的结果合并

return array_merge($left,array($arr[0]),$right);

}

//调用

echo "<pre>";

print_r(quick_sort($arr));

5. 选择排序—简单选择排序（Simple Selection Sort）

基本思想：

在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。

简单选择排序的示例：

操作方法：

第一趟，从n 个记录中找出关键码最小的记录与第一个记录交换；

第二趟，从第二个记录开始的n-1 个记录中再选出关键码最小的记录与第二个记录交换；

以此类推.....

第i 趟，则从第i 个记录开始的n-i+1 个记录中选出关键码最小的记录与第i 个记录交换，

直到整个序列按关键码有序。

6. 选择排序—堆排序（Heap Sort）

堆排序是一种树形选择排序，是对直接选择排序的有效改进。

基本思想：

堆的定义如下：具有n个元素的序列（k1,k2,...,kn),当且仅当满足

时称之为堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最小项（小顶堆）。
若以一维数组存储一个堆，则堆对应一棵完全二叉树，且所有非叶结点的值均不大于(或不小于)其子女的值，根结点（堆顶元素）的值是最小(或最大)的。如：

（a）大顶堆序列：（96, 83,27,38,11,09)

(b) 小顶堆序列：（12，36，24，85，47，30，53，91）

初始时把要排序的n个数的序列看作是一棵顺序存储的二叉树（一维数组存储二叉树），调整它们的存储序，使之成为一个堆，将堆顶元素输出，得到n 个元素中最小(或最大)的元素，这时堆的根节点的数最小（或者最大）。然后对前面(n-1)个元素重新调整使之成为堆，输出堆顶元素，得到n 个元素中次小(或次大)的元素。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。称这个过程为堆排序。

因此，实现堆排序需解决两个问题：
1. 如何将n 个待排序的数建成堆；
2. 输出堆顶元素后，怎样调整剩余n-1 个元素，使其成为一个新堆。

首先讨论第二个问题：输出堆顶元素后，对剩余n-1元素重新建成堆的调整过程。
调整小顶堆的方法：

1）设有m 个元素的堆，输出堆顶元素后，剩下m-1 个元素。将堆底元素送入堆顶（（最后一个元素与堆顶进行交换），堆被破坏，其原因仅是根结点不满足堆的性质。

2）将根结点与左、右子树中较小元素的进行交换。

3）若与左子树交换：如果左子树堆被破坏，即左子树的根结点不满足堆的性质，则重复方法（2）.

4）若与右子树交换，如果右子树堆被破坏，即右子树的根结点不满足堆的性质。则重复方法（2）.

5）继续对不满足堆性质的子树进行上述交换操作，直到叶子结点，堆被建成。

称这个自根结点到叶子结点的调整过程为筛选。如图：

再讨论对n 个元素初始建堆的过程。
建堆方法：对初始序列建堆的过程，就是一个反复进行筛选的过程。

1）n 个结点的完全二叉树，则最后一个结点是第个结点的子树。

2）筛选从第个结点为根的子树开始，该子树成为堆。

3）之后向前依次对各结点为根的子树进行筛选，使之成为堆，直到根结点。

如图建堆初始过程：无序序列：（49，38，65，97，76，13，27，49）

算法的实现：

从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。

<?php

//堆排序（对简单选择排序的改进）

function swap(array &$arr,$a,$b){

$temp = $arr[$a];

$arr[$a] = $arr[$b];

$arr[$b] = $temp;

}

//调整 $arr[$start]的关键字，使$arr[$start]、$arr[$start+1]、、、$arr[$end]成为一个大根堆（根节点最大的完全二叉树）

//注意这里节点 s 的左右孩子是 2*s + 1 和 2*s+2 （数组开始下标为 0 时）

function HeapAdjust(array &$arr,$start,$end){

$temp = $arr[$start];

//沿关键字较大的孩子节点向下筛选

//左右孩子计算（我这里数组开始下标识 0）

//左孩子2 * $start + 1，右孩子2 * $start + 2

for($j = 2 * $start + 1;$j <= $end;$j = 2 * $j + 1){

if($j != $end && $arr[$j] < $arr[$j + 1]){

$j ++; //转化为右孩子

}

if($temp >= $arr[$j]){

break; //已经满足大根堆

}

//将根节点设置为子节点的较大值

$arr[$start] = $arr[$j];

//继续往下

$start = $j;

}

$arr[$start] = $temp;

}

function HeapSort(array &$arr){

$count = count($arr);

//先将数组构造成大根堆（由于是完全二叉树，所以这里用floor($count/2)-1，下标小于或等于这数的节点都是有孩子的节点)

for($i = floor($count / 2) - 1;$i >= 0;$i --){

HeapAdjust($arr,$i,$count);

}

for($i = $count - 1;$i >= 0;$i --){

//将堆顶元素与最后一个元素交换，获取到最大元素（交换后的最后一个元素），将最大元素放到数组末尾

swap($arr,0,$i);

//经过交换，将最后一个元素（最大元素）脱离大根堆，并将未经排序的新树($arr[0...$i-1])重新调整为大根堆

HeapAdjust($arr,0,$i - 1);

}

$arr = array(9,1,5,8,3,7,4,6,2);

HeapSort($arr);

var_dump($arr);

7. 归并排序（Merge Sort）

基本思想：

归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

利用归并（合并）的思想实现的排序方法。它的原理是假设初始序列含有 n 个元素，则可以看成是 n 个有序的子序列，每个子序列的长度为 1，然后两两归并，得到 ⌈ n / 2⌉ （⌈ x ⌉ 表示不小于 x 的最小整数）个长度为 2 或 1 的有序序列；再两两归并，······，如此重复，直至得到一个长度为 n 的有序序列为止，这种排序方法就成为 2 路归并排序。

归并排序示例：

合并方法：

/**

* mergeSort 归并排序

* 是开始递归函数的一个驱动函数

* @param &$arr array 待排序的数组

function mergeSort(&$arr) {

$len = count($arr);//求得数组长度

mSort($arr, 0, $len-1);

}

/**

* 实际实现归并排序的程序

* @param &$arr array 需要排序的数组

* @param $left int 子序列的左下标值

* @param $right int 子序列的右下标值

function mSort(&$arr, $left, $right) {

if($left < $right) {

//说明子序列内存在多余1个的元素，那么需要拆分，分别排序，合并

//计算拆分的位置，长度/2 去整

$center = floor(($left+$right) / 2);

//递归调用对左边进行再次排序：

mSort($arr, $left, $center);

//递归调用对右边进行再次排序

mSort($arr, $center+1, $right);

//合并排序结果

mergeArray($arr, $left, $center, $right);

}

/**

* 将两个有序数组合并成一个有序数组

* @param &$arr, 待排序的所有元素

* @param $left, 排序子数组A的开始下标

* @param $center, 排序子数组A与排序子数组B的中间下标，也就是数组A的结束下标

* @param $right, 排序子数组B的结束下标（开始为$center+1)

function mergeArray(&$arr, $left, $center, $right) {

//设置两个起始位置标记

$a_i = $left;

$b_i = $center+1;

while($a_i<=$center && $b_i<=$right) {

//当数组A和数组B都没有越界时

if($arr[$a_i] < $arr[$b_i]) {

$temp[] = $arr[$a_i++];

} else {

$temp[] = $arr[$b_i++];

}

//判断数组A内的元素是否都用完了，没有的话将其全部插入到C数组内：

while($a_i <= $center) {

$temp[] = $arr[$a_i++];

}

//判断数组B内的元素是否都用完了，没有的话将其全部插入到C数组内：

while($b_i <= $right) {

$temp[] = $arr[$b_i++];

}

//将$arrC内排序好的部分，写入到$arr内：

for($i=0, $len=count($temp); $i<$len; $i++) {

$arr[$left+$i] = $temp[$i];

}

//do some test:

$arr = array(4, 7, 6, 3, 9, 5, 8);

mergeSort($arr);

print_r($arr);

8. 桶排序/基数排序(Radix Sort)

基本思想

基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O (nlog(r)m)，其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的稳定性排序法。

基本解法：

PS：在这里我们介绍的基数排序我们采用 LSD（最低位优先），当然还有 MSD（最高位优先），大家自己去百度一下他们之间的异同吧。

假如现在我们有以下这么一些数：

2 343 342 1 128 43 4249 814 687 654 3

我们使用基数排序将他们从小到大排序。

第一步、首先根据个位数的数值，在走访数值（从前到后走访，后面步骤相同）时将它们分配至编号0到9的桶子中：

0 :

1 : 1

2 : 2 342

3 : 343 43 3

4 : 814 654

5 :

6 :

7 : 687

8 : 128

9 : 4249

第二步、接下来将这些桶子中的数值重新串接起来，成为以下的数列：

1 2 342 343 43 3 814 654 687 128 4249

第三步、根据十位数的数值，在走访数值（从前到后走访，后面步骤相同）时将它们分配至编号0到9的桶子中：

0 : 1 2 3

1 : 814

2 : 128

3 :

4 : 342 343 43 4249

5 : 654

6 :

7 :

8 : 687

9 :

第四步、接下来将这些桶子中的数值重新串接起来，成为以下的数列：

1 2 3 814 128 342 343 43 4249 654 687

第五步、根据百位数的数值，在走访数值（从前到后走访，后面步骤相同）时将它们分配至编号0到9的桶子中：

0 : 1 2 3 43

1 : 128

2 : 4249

3 : 342 343

4 :

5 :

6 : 654 687

7 :

8 : 814

9 :

第六步、接下来将这些桶子中的数值重新串接起来，成为以下的数列：

1 2 3 43 128 4249 342 343 654 687 814

后面的步骤大家应该都会走了吧。其实到了第六步的时候就剩 4249 没有排好序了。

从上面的步骤来看，很多的步骤都是相同的，因此肯定是个循环了，我们只需要控制个位、十位、百位、、、、就好了。

//交换函数function swap(array &$arr,$a,$b){

$temp = $arr[$a];

$arr[$a] = $arr[$b];

$arr[$b] = $temp;

}

//获取数组中的最大数//就像上面的例子一样，我们最终是否停止算法不过就是看数组中的最大值：4249，它的位数就是循环的次数function getMax(array $arr){

$max = 0;

$length = count($arr);

for($i = 0;$i < $length;$i ++){

if($max < $arr[$i]){

$max = $arr[$i];

}

return $max;

}

//获取最大数的位数,最大值的位数就是我们分配桶的次数function getLoopTimes($maxNum){

$count = 1;

$temp = floor($maxNum / 10);

while($temp != 0){

$count ++;

$temp = floor($temp / 10);

}

return $count;

}

/**

* @param array $arr 待排序数组

* @param $loop 第几次循环标识

* 该函数只是完成某一位（个位或十位）上的桶排序

*/function R_Sort(array &$arr,$loop){

$tempArr = array();

$count = count($arr);

for($i = 0;$i < 10;$i ++){

$tempArr[$i] = array();

}

//求桶的index的除数

//如798个位桶index=(798/1)%10=8

//十位桶index=(798/10)%10=9

//百位桶index=(798/100)%10=7

//$tempNum为上式中的1、10、100

$tempNum = (int)pow(10, $loop - 1);

for($i = 0;$i < $count;$i ++){

//求出某位上的数字

$row_index = ($arr[$i] / $tempNum) % 10;

//入桶

array_push($tempArr[$row_index],$arr[$i]);

}

//还原回原数组中

$k = 0;

for($i = 0;$i < 10;$i ++){

//出桶

while(count($tempArr[$i]) > 0){

$arr[$k ++] = array_shift($tempArr[$i]);

}

//最终调用的主函数function RadixSort(array &$arr){

$max = getMax($arr);

$loop = getLoopTimes($max);

//对每一位进行桶分配（1 表示个位，$loop 表示最高位）

for($i = 1;$i <= $loop;$i ++){

R_Sort($arr,$i);

}

$arr = array(2, 343, 342, 1, 128, 43, 4249, 814, 687, 654, 3);

RadixSort($arr);

var_dump($arr);

php_elephant

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
排序算法

排序算法八大排序插入排序:直接插入排序、希尔排序交换排序:冒泡排序、快速排序选择排序:简单选择排序、堆排序归并排序基数排序1.插入排序—直接插入排序(Straight Insertion Sort)基本思想:将一个记录插入到已排序好的有序表中，从而得到一个新记录数增1的有序表。即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。要点：设立哨兵，作为临...
复制链接

扫一扫