本文实例讲述了PHP四种排序算法实现及效率分析，分享给大家供大家参考，具体如下：

PHP的四种基本排序算法为：冒泡排序、插入排序、选择排序和快速排序。

下面是我整理出来的算法代码：

1. 冒泡排序：

思路：对数组进行多轮冒泡，每一轮对数组中的元素两两比较，调整位置，冒出一个最大的数来。

1. //简单版： 
2. function bubbleSort($arr) 
3. { 
4.    $n = count($arr); 
5.    for($i=1;$i<$n;$i++) { //冒泡的轮数(最多$n-1轮) 
6.      for($j=0;$j<$n-1;$j++) { //每一轮冒泡(两两比较，大者后移) 
7.        if($arr[$j] > $arr[$j+1]) { //前者大于后者，交换位置 
8.           $tmp = $arr[$j]; 
9.           $arr[$j] = $arr[$j+1]; 
10.           $arr[$j+1] = $tmp; 
11.        } 
12.      } 
13.    } 
14.    return $arr; 
15. } 
16.  
17. //改进版： 
18. function bubbleSort($arr) 
19. { 
20.    $n = count($arr); 
21.    for($i=1;$i<$n;$i++) { //冒泡的轮数(最多$n-1轮) 
22.      $flag = 0;  //是否发生位置交换的标志 
23.      for($j=0;$j<$n-$i;$j++) { //每一轮冒泡(两两比较，大者后移) 
24.        if($arr[$j] > $arr[$j+1]) { //前者大于后者，交换位置 
25.           $tmp = $arr[$j]; 
26.           $arr[$j] = $arr[$j+1]; 
27.           $arr[$j+1] = $tmp; 
28.           $flag = 1; 
29.        } 
30.      } 
31.      if($flag == 0) {  //没有发生位置交换，排序已完成 
32.        break; 
33.      } 
34.    } 
35.    return $arr; 
36. } 

为了提高冒泡排序算法的效率，主要需要改进的地方有：

（1）减少冒泡的轮数：当一轮冒泡排序中没有发生位置交换时表示数组已排好序了，应立即退出循环。

（2）减少每一轮比较的次数：对数组中已经排好序的部分元素不再对它们进行比较。

2. 插入排序：

思路：假设数组前面的元素是排好序的，遍历数组后面的元素，在已排好序的元素队列中找到合适的位置，插入其中。

1. function insertSort($arr) 
2. { 
3.    $n = count($arr); 
4.    for($i=1;$i<$n;$i++) { //从第二个元素开始插入 
5.      for($j=$i-1;$j>=0;$j--) { //与前面的数比较，找到插入的位置 
6.        if($arr[$j] > $arr[$j+1]) { //比前面的数小，交换位置 
7.           $tmp = $arr[$j]; 
8.           $arr[$j] = $arr[$j+1]; 
9.           $arr[$j+1] = $tmp; 
10.        } else { //大于或等于前面的数，表示已找到插入的位置 
11.           break; 
12.        } 
13.      } 
14.    } 
15.    return $arr; 
16. } 

3. 选择排序：

思路：进行多次选择，每次选出最大元素放入指定位置。

1. function selectSort($arr) 
2. { 
3.    $n = count($arr); 
4.    for($i=$n-1;$i>0;$i--) { //选择排序的轮数($n-1轮) 
5.      $pos = $i; //假设最大元素的位置 
6.      for($j=0;$j<$i;$j++) { //每一轮：从未选择过的元素中选择最大的数 
7.        if($arr[$j] > $arr[$pos]) { //所在位置元素比目前最大元素大，标志其位置 
8.           $pos = $j; 
9.        } 
10.      } 
11.      if($pos != $i) { //将最大元素放入指定的位置 
12.        $tmp = $arr[$pos]; 
13.        $arr[$pos] = $arr[$i]; 
14.        $arr[$i] = $tmp; 
15.      } 
16.    } 
17.    return $arr; 
18. } 

4. 快速排序：

思路：递归算法。先选择数组的第一个元素作为标准，然后把小于或等于它和大于它的数分别放入两个数组中，对这两个数组也进行相同的处理，最后合并这两个数组和第一个元素。

1. function quickSort($arr) 
2. { 
3.    $n = count($arr); 
4.    if($n <= 1) { //若数组只有一个元素，直接返回 
5.      return $arr; 
6.    } 
7.    $largeArr = array(); //存放大数 
8.   $smallArr = array(); //存放小数 
9.    $cur = $arr[0];  //分类基数 
10.    for($i=1;$i<$n;$i++) { //遍历数组元素，对每个元素进行归类 
11.      if($arr[$i] > $cur) { 
12.        $largeArr[] = $arr[$i]; 
13.      } else { 
14.        $smallArr[] = $arr[$i]; 
15.      } 
16.    } 
17.    //分别对大数组和小数组进行相同的处理 
18.    $smallArr = quickSort($smallArr); 
19.    $largeArr = quickSort($largeArr); 
20.    //合并小数组、分类基数和大数组 
21.    return array_merge($smallArr,array($cur),$largeArr); 
22. } 

各个排序算法的时间复杂度和空间复杂度：

排序算法 最好时间分析 最差时间分析 平均时间复杂度 稳定度 空间复杂度

冒泡排序 O(n) O(n2) O(n2) 稳定 O(1)

插入排序 O(n) O(n2) O(n2) 稳定 O(1)

选择排序 O(n2) O(n2) O(n2) 稳定 O(1)

快速排序 O(nlog2n) O(n2) O(nlog2n) 不稳定 O(log2n)~O(n)

注：快速排序在数组乱序是效率是最好的，在数组有序时效率是最差的。

Tags: PHP冒泡排序 PHP插入排序

分享到：