php 实现十大经典排序算法

算法工具地址：非常好

 https://algorithm-visualizer.org/brute-force/insertion-sort

算法概述

01、算法分类：

十种常见排序算法可以分为两大类：

非线性时间比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此称为非线性时间比较类排序。

线性时间非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此称为线性时间非比较类排序。

02、算法复杂度

03、相关概念

稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。

不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。

时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。

空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。

冒泡排序（Buttle Sort）

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

（1）、算法描述：

• 比较相邻的元素。如果第一个比第二个大，就交换它们两个；

• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；

• 针对所有的元素重复以上的步骤，除了最后一个；

• 重复步骤1~3，直到排序完成。

（2）、算法动图：

（3）、代码实现：

1. /*

2. * 冒泡排序

3. * @param array $arr

4. * @return array

5. */

6. function bubbleSort($arr) {

7. for($i = 0; $i < count($arr); $i++){          #第一次循环: 一共循环的次数,数组中有多少个数据，就循环多少次

8. for($j = 0; $j < count($arr)-1-$i; $j++){       #第二次循环: 要比较数据的个数，第一次循完之后，就已经把一个数据循环排好了，所以就不需要再对这个数据进行排序了,这里减1的目的是剩最后一个数的时候就不用比较

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

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

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

12. $arr[$j] = $temp;

13. }

14. }

15. }

16.  

17. return $arr;

18. }

选择排序（Selection Sort）

选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

（1）、算法描述：

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

• 初始状态：无序区为R[1..n]，有序区为空；

• 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；

• n-1趟结束，数组有序化了。

（2）、算法动图：

（3）、代码实现：

1. /*

2. * 选择排序

3. * @param array $arr

4. * @return array

5. */

6. function selectionSort($arr) {

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

8. $minIndex = $i;

9. for($j = $i + 1; $j < count($arr); $j++) {

10. if ($arr[$j] < $arr[$minIndex]) {

11. $minIndex = $j;

12. }

13. }

14. $temp = $arr[$i];

15. $arr[$i] = $arr[$minIndex];

16. $arr[$minIndex] = $temp;

17. }

18. return $arr;

19. }

（4）、算法分析：

表现最稳定的排序算法之一，因为无论什么数据进去都是O(n2)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法了吧。

插入排序（Insertion Sort）

插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

（1）、算法描述：

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

• 从第一个元素开始，该元素可以认为已经被排序；

• 取出下一个元素，在已经排序的元素序列中从后向前扫描；

• 如果该元素（已排序）大于新元素，将该元素移到下一位置；

• 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；

• 将新元素插入到该位置后；

• 重复步骤2~5。

（2）、算法动图：

（3）、代码实现：

function insertSort($arr) {

  $len = count($arr); 

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

    if($arr[$i-1] > $arr[i]) {

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

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

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

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

          $arr[$j] = $tmp;

        }else{

          break;

        }         

      } 

    }

  } 

  return $arr;

}

（4）、算法分析：

插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

希尔排序（Shell Sort）

1959年Shell发明，第一个突破O(n2)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

（1）、算法描述：

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：

• 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；

• 按增量序列个数k，对序列进行k 趟排序；

• 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

（2）、算法动图：

（3）、代码实现：

1. /*

2. * 希尔排序

3. * @param array $arr

4. * @return array

5. */

6. function shellSort($arr){

7. $factor = 3; //定义因子

8. $gap = 1; //最小值

9. while ($gap < intval(count($arr) / $factor)){

10. $gap = $factor * $gap + 1;

11. }

12.  

13. while ($gap >= 1){

14. for ($i = $gap; $i < count($arr); $i++){

15. for ($j = $i; $j >= $gap && $arr[$j] < $arr[$j-$gap]; $j -= $gap){

16. $temp = $arr[$j];

17. $arr[$j] = $arr[$j-$gap];

18. $arr[$j-$gap] = $temp;

19. }

20. }

21. $gap = intval($gap / $factor);

22. }

23.  

24. return $arr;

25. }

（4）、算法分析：

希尔排序的核心在于间隔序列的设定。既可以提前设定好间隔序列，也可以动态的定义间隔序列。动态定义间隔序列的算法是《算法（第4版）》的合著者Robert Sedgewick提出的。

归并排序（Merge Sort）

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

（1）、算法描述：

• 把长度为n的输入序列分成两个长度为n/2的子序列；

• 对这两个子序列分别采用归并排序；

• 将两个排序好的子序列合并成一个最终的排序序列。

（2）、算法动图：

（3）、代码实现：

1. /*

2. * 归并排序

3. * @param array $arr

4. * @return array

5. */

6. function mergeSort($arr) {

7. if (count($arr) < 2) {

8. return $arr;

9. }

10. $middle = floor(count($arr) / 2);

11. $left = array_slice($arr,0, $middle);

12. $right = array_slice($arr,$middle,count($arr)-$middle);

13. return mergeArr(mergeSort($left), mergeSort($right));

14. }

15.  

16. function mergeArr($left, $right) {

17. $res = [];

18. while (count($left) > 0 && count($right) > 0) {

19. if($left[0] <= $right[0]){

20. array_push($res,array_shift($left));

21. }else{

22. array_push($res,array_shift($right));

23. }

24. }

25.  

26. while(count($left)){

27. array_push($res,array_shift($left));

28. }

29. while (count($right)){

30. array_push($res,array_shift($right));

31. }

32. return $res;

33. }

（4）、算法分析：

归并排序是一种稳定的排序方法。和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(nlogn）的时间复杂度。代价是需要额外的内存空间。

快速排序（Quick Sort）

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

（1）、算法描述：

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

• 从数列中挑出一个元素，称为 “基准”（pivot）；

• 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；

• 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

（2）、算法动图：

（3）、代码实现：

1. /*

2. * 快速排序

3. * @param array $arr

4. * @return array

5. */

6. function quickSort($arr) {

7. if(count($arr) <= 1) {

8. return $arr;

9. }

10. $key = $arr[0];

11. $rightArray = array();

12. $leftArray = array();

13. for($i = 1; $i < count($arr); $i++) {

14. if($arr[$i] >= $key) {

15. $rightArray[] = $arr[$i];

16. } else {

17. $leftArray[] = $arr[$i];

18. }

19. }

20. $leftArray = quickSort($leftArray);

21. $rightArray = quickSort($rightArray);

22. return array_merge($leftArray, array($key), $rightArray);

23. }

24.  

25. //注意：该方式效率较低，但比较直观

堆排序（Heap Sort）

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

（1）、算法描述：

• 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；

• 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=r[n]；< span=""></=r[n]；<>

• 由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

（2）、算法动图：

（3）、代码实现：

1. /*

2. * 堆排序

3. * @param array $arr

4. * @return array

5. */

6. function heapSort($arr){

7. $len = count($arr);

8.  

9. //初始化堆

10. for($start=floor($len/2)-1; $start>=0; $start--){

11. adjustHeap($arr,$start,$len-1);

12. }

13.  

14. for($end = $len-1; $end > 0; $end--){

15. $tmp = $arr[$end];

16. $arr[$end] = $arr[0];

17. $arr[0] = $tmp;

18.  

19. //调整堆，堆顶元素破坏了堆结构

20. adjustHeap($arr,0,$end-1);

21. }

22. return $arr;

23. }

24.  
25.  

26. /*

27. * @param array $arr

28. * @param int $start

29. * @param int $end

30. */

31. function adjustHeap(&$arr,$start,$end){

32. $max = $start;

33. $lchild_index = 2*($start+1)-1;

34. $rchild_index = 2*($start+1);

35.  

36. if($lchild_index <= $end){

37. if($arr[$lchild_index]>$arr[$max]){

38. $max = $lchild_index;

39. }

40.  

41. if($rchild_index <=$end && $arr[$rchild_index] > $arr[$max]){

42. $max = $rchild_index;

43. }

44. }

45.  

46. if($max != $start){

47. $tmp = $arr[$start];

48. $arr[$start] = $arr[$max];

49. $arr[$max] = $tmp;

50.  

51. adjustHeap($arr, $max, $end);

52. }

53. }

计数排序（Counting Sort）

计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

（1）、算法描述：

• 找出待排序的数组中最大和最小的元素；

• 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；

• 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；

• 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。

（2）、算法动图：

（3）、代码实现：

1. /*

2. * 计数排序

3. * @param array $arr

4. * @return array

5. */

6. function countingSort($arr){

7. $length = count($arr);

8. $maxValue = $arr[0];

9.  

10. // 找出数组中的最大值

11. for ($i=1; $i < $length; $i++) {

12. if ($arr[$i] > $maxValue) {

13. $maxValue = $arr[$i];

14. }

15. }

16.  

17. /*

18. * 定长数组, 键会自动排序, PHP数组是hash表的实现,

19. * 如果这里用普通的数组, 键不会自动排序, 不存在的键也不会自动填充null

20. */

21. $frequency = new SplFixedArray($maxValue + 1);

22.  

23. /*

24. * 统计arr中, 值出现的频次

25. */

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

27. if(empty($frequency[$arr[$i]]))

28. $frequency[$arr[$i]] = 0;

29. $frequency[$arr[$i]] += 1;

30. }

31.  

32. // 清空$arr

33. $arr = [];

34. // 遍历frequency, 如果其元素有值, 那么将键push到arr中

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

36. if (!empty($frequency[$i])) {

37. for ($j=0; $j < $frequency[$i]; $j++) {

38. $arr[] = $i;

39. }

40. }

41. }

42.  

43. return $arr;

44. }

（4）、算法分析：

计数排序是一个稳定的排序算法。当输入的元素是 n 个 0到 k 之间的整数时，时间复杂度是O(n+k)，空间复杂度也是O(n+k)，其排序速度快于任何比较排序算法。当k不是很大并且序列比较集中时，计数排序是一个很有效的排序算法。

桶排序（Bucket Sort）

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排）。

（1）、算法描述：

• 设置一个定量的数组当作空桶；

• 遍历输入数据，并且把数据一个一个放到对应的桶里去；

• 对每个不是空的桶进行排序；

• 从不是空的桶里把排好序的数据拼接起来。

（2）、算法动图：

（3）、代码实现：

1. /*

2. * 桶排序

3. * @param array $arr

4. * @return array

5. */

6. function bucketSort($arr){

7. $res=[];

8. $len=count($arr);

9.  

10. //入桶

11. for($i=0,$max=$arr[$i];$i<$len;$i++){

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

13. $max=$arr[$i];

14. }

15. $bucket[$arr[$i]]=[];

16. array_push($bucket[$arr[$i]],$arr[$i]);

17. }

18.  

19. //出桶

20. for($i=0;$i<=$max;$i++){

21. if(!empty($bucket[$i])){

22. $l=count($bucket[$i]);

23. for ($j=0; $j <$l ; $j++) {

24. $result[]=$bucket[$i][$j];

25. }

26. }

27. }

28. return $result;

29. }

（4）、算法分析：

桶排序最好情况下使用线性时间O(n)，桶排序的时间复杂度，取决与对各个桶之间数据进行排序的时间复杂度，因为其它部分的时间复杂度都为O(n)。很显然，桶划分的越小，各个桶之间的数据越少，排序所用的时间也会越少。但相应的空间消耗就会增大。

基数排序（Radix Sort）

基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。

（1）、算法描述：

• 取得数组中的最大数，并取得位数；

• arr为原始数组，从最低位开始取每个位组成radix数组；

• 对radix进行计数排序（利用计数排序适用于小范围数的特点）；

（2）、算法动图：

（3）、代码实现：

1. /*

2. * 基数排序

3. * @param array $arr

4. * @return array

5. */

6. function radixSort($arr) {

7. //先求出数组中最大的位数

8. $max = max($arr);

9. $max_digit = get_digit($max);

10.  

11. for ($i = 1; $i <= $max_digit; $i++) {

12. counting_sort($arr, $i);

13. }

14.  

15. return $arr;

16. }

17.  

18. function counting_sort(&$arr, $digit_num = false) {

19. if ($digit_num !== false) {

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

21. $arr_temp[$i] = get_specific_digit($arr[$i], $digit_num);

22. }

23. } else {

24. $arr_temp = $arr;

25. }

26.  

27. $max = max($arr);

28. $time_arr = array(); //储存元素出现次数的数组

29.  

30. //初始化出现次数数组

31. for ($i = 0; $i <= $max; $i++) {

32. $time_arr[$i] = 0;

33. }

34.  

35. //统计每个元素出现次数

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

37. $time_arr[$arr_temp[$i]]++;

38. }

39.  

40. //统计每个元素比其小或相等的元素出现次数

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

42. $time_arr[$i + 1] += $time_arr[$i];

43. }

44.  

45. //利用出现次数对数组进行排序

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

47. $sorted_arr[$time_arr[$arr_temp[$i]] - 1] = $arr[$i];

48. $time_arr[$arr_temp[$i]]--;

49. }

50.  

51. $arr = $sorted_arr;

52. ksort($arr); //忽略这次对key排序的效率损耗

53. }

54.  

55. /*

56. * 计算某个数的位数

57. */

58. function get_digit($number) {

59. $i = 1;

60. while ($number >= pow(10, $i)) {

61. $i++;

62. }

63.  

64. return $i;

65. }

66.  

67. /*

68. * 获取某个数字的从个位算起的第i位数

69. */

70. function get_specific_digit($num, $i) {

71. if ($num < pow(10, $i - 1)) {

72. return 0;

73. }

74. return floor($num % pow(10, $i) / pow(10, $i - 1));

75. }

（4）、算法分析：

基数排序基于分别排序，分别收集，所以是稳定的。但基数排序的性能比桶排序要略差，每一次关键字的桶分配都需要O(n)的时间复杂度，而且分配之后得到新的关键字序列又需要O(n)的时间复杂度。假如待排数据可以分为d个关键字，则基数排序的时间复杂度将是O(d*2n) ，当然d要远远小于n，因此基本上还是线性级别的。

基数排序的空间复杂度为O(n+k)，其中k为桶的数量。一般来说n>>k，因此额外空间需要大概n个左右。

1、插入排序

/*
 *  直接插入排序,插入排序的思想是：当前插入位置之前的元素有序，
 *  若插入当前位置的元素比有序元素最后一个元素大，则什么也不做，
 *  否则在有序序列中找到插入的位置，并插入
 *  方式1
 */
function insertSort($arr) {
  $len = count($arr);
  for($i = 1; $i < $len; $i++) {
    if($arr[$i-1] > $arr[i]) {
      for($j = $i - 1;$j >= 0; $j-- ) {
        $tmp = $arr[$j+1];
        if($tmp < $arr[$j]) {
          $arr[$j+1] = $arr[$j];
          $arr[$j] = $tmp;
        }else{
          break;
        }
      }
    }
  }
  return $arr;
}
// 方式2(从大到小排) function quiclySort($arr) {     $count = count($arr);     for ($i=1;$i<$count;$i++) {             $tmp = $arr[$i];             $j = $i - 1;             while ($j >= 0 && $tmp > $arr[$j]) {                     $arr[$j+1] = $arr[$j--];             }             $arr[$j+1] = $tmp;     }     return $arr; }

2、冒泡排序

/*
  冒泡排序,冒泡排序思想：进行 n-1 趟冒泡排序， 每趟两两比较调整最大值到数组（子数组）末尾
*/
function bubbleSort($arr) {
  $len = count($arr);
  for($i = 1; $i < $len; $i++) {
    for($j = 0; $j < $len-$i; $j++) {
      if($arr[$j] > $arr[$j+1]) {
        $tmp = $arr[$j+1];
        $arr[$j+1] = $arr[$j];
        $arr[$j] = $tmp;
      }
    }
  }
  return $arr;
}

3、选择排序

/*
 *  在要排序的一组数中，选出最小的一个数与第一个位置的数交换。然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。
*/
function selectSort($arr) { //双重循环完成，外层控制轮数，内层控制比较次数  $len=count($arr);     for($i=0; $i<$len-1; $i++) {         //先假设最小的值的位置         $p = $i;         for($j=$i+1; $j<$len; $j++) {             //$arr[$p] 是当前已知的最小值             if($arr[$p] > $arr[$j]) {             //比较，发现更小的,记录下最小值的位置；并且在下次比较时采用已知的最小值进行比较。                 $p = $j;             }         }         //已经确定了当前的最小值的位置，保存到$p中。如果发现最小值的位置与当前假设的位置$i不同，则位置互换即可。         if($p != $i) {             $tmp = $arr[$p];             $arr[$p] = $arr[$i];             $arr[$i] = $tmp;         }     }     //返回最终结果     return $arr; }

4、希尔排序

/*
  希尔排序,希尔排序原理：将数组按指定步长分隔成若干子序列，然后分别对子序列进行排序（在这是直接）
*/
function shellSort($arr) {
  $len = count($arr);
  $k = floor($len/2);
  while($k > 0) {
    for($i = 0; $i < $k; $i++) {
      for($j = $i; $j < $len, ($j + $k) < $len; $j = $j + $k) {
        if($arr[$j] > $arr[$j+$k]) {
          $tmp = $arr[$j+$k];
          $arr[$j+$k] = $arr[$j];
          $arr[$j] = $tmp;
        }
      }
    }
    $k = floor($k/2);
  }
  return $arr;
}

5、快速排序

/*
 *  快速排序,快排思想：通过一趟排序将待排的记录分为两个独立的部分，其中一部分的记录的关键字均不大于
 *  另一部分记录的关键字，然后再分别对这两部分记录继续进行快速排序，以达到整个序列有序，具体做法需要
 *  每趟排序设置一个标准关键字和分别指向头一个记录的关键字和最后一个记录的关键字的指针。
 *  quickSort($arr, 0, count($arr) -1);
 */
function quickSort(&$arr,$low,$high) {
  if($low < $high) {
    $i = $low;
    $j = $high;
    $primary = $arr[$low];
    while($i < $j) {
      while($i < $j && $arr[$j] >= $primary) {
        $j--;
      }
      if($i < $j) {
        $arr[$i++] = $arr[$j];
      }
      while($i < $j && $arr[$i] <= $primary) {
        $i++;
      }
      if($i < $j) {
        $arr[$j--] = $arr[$i];
      }
    }
    $arr[$i] = $primary;
    quickSort($arr, $low, $i-1);
    quickSort($arr, $i+1, $high);
  }
}

6、堆排序

/*
  堆排序
*/
// 调整子堆的为大根堆的过程，$s为子堆的根的位置，$m为堆最后一个元素位置
function heapAdjust(&$arr, $s, $m) {
  $tmp = $arr[$s];
  // 在调整为大根堆的过程中可能会影响左子堆或右子堆
  // for循环的作用是要保证子堆也是大根堆
  for($j = 2*$s + 1; $j <= $m; $j = 2*$j + 1) {
    // 找到根节点的左右孩子中的最大者，然后用这个最大者与根节点比较，
    // 若大则进行调整，否则符合大根堆的 特点跳出循环
    if($j < $m && $arr[$j] < $arr[$j+1]) {
      $j++;
    }
    if($tmp >= $arr[$j] ) {
      break;
    }
    $arr[$s] = $arr[$j];
    $s = $j;
  }
  $arr[$s] = $tmp;
}
// 堆排序
function heapSort($arr) {
  $len = count($arr);
  // 依次从子堆开始调整堆为大根堆
  for($i = floor($len/2-1); $i >= 0; $i--) {
    heapAdjust($arr, $i, $len-1);
  }
  // 依次把根节点调换至最后一个位置，再次调整堆为大根堆，找到次最大值，
  // 依次类推得到一个有序数组
  for($n = $len-1; $n > 0; $n--) {
    $tmp = $arr[$n];
    $arr[$n] = $arr[0];
    $arr[0] = $tmp;
    heapAdjust($arr, 0, $n-1);
  }
  return $arr;
}

7、归并排序

/*
  归并排序,这里实现的是两路归并
*/
// 分别将有序的$arr1[s..m]、$arr2[m+1..n]归并为有序的$arr2[s..n]
function Merge(&$arr1, &$arr2, $s, $m, $n) {
  for($k = $s,$i = $s, $j = $m+1; $i <= $m && $j <= $n; $k++) {
    if($arr1[$i]<$arr1[$j]) {
      $arr2[$k] = $arr1[$i++];
    }else {
      $arr2[$k] = $arr1[$j++];
    }
  }
  if($i <= $m) {
    for(; $i <= $m; $i++) {
      $arr2[$k++] = $arr1[$i];
    }
  } else if($j <= $n) {
    for(; $j <= $n; $j++) {
      $arr2[$k++] = $arr1[$j];
    }
  }
}
// 递归形式的两路归并
function MSort(&$arr1, &$arr2, $s, $t) {
  if($s == $t) {
    $arr2[$s] = $arr1[$s];
  }else {
    $m = floor(($s+$t)/2);
    $tmp_arr = array();
    MSort($arr1, $tmp_arr, $s, $m);
    MSort($arr1, $tmp_arr, $m+1, $t);
    Merge($tmp_arr, $arr2, $s, $m, $t);
  }
}
// 对一位数组$arr[0..n-1]中的元素进行两路归并
function mergeSort($arr) {
  $len = count($arr);
  MSort($arr, $arr, 0, $len-1);
  return $arr;
}

二分查找又称折半查找，二分查找算法要求数据必须是有序的，以下是php实现二分查找算法的代码。
一：递归方式

$array = [1,3,6,9,13,18,19,29,38,47,51,56,58,59,60,63,65,69,70,71,73,75,76,77,79,89];
$target = 73;
$low = 0;
$high = count($array)-1;
function bin_search($array, $low, $high, $target){
        if ( $low <= $high){
            var_dump($low, $high);echo "\n";
            $mid =  intval(($low+$high)/2 );
        if ($array[$mid] ==  $target){
                    return true;
        }elseif ( $target < $array[$mid]){
                    return  bin_search($array, $low,  $mid-1, $target);
        }else{
                    return  bin_search($array, $mid+ 1, $high, $target);
        }
    }
    return false;
}
$find = bin_search($array, $low, $high, $target);
var_dump($find);

执行结果
int(0)
int(25)
int(13)
int(25)
int(20)
int(25)
int(20)
int(21)
bool(true)

我们看到，经过4次二分查找，查找区间不断折半，最终找到了$target。



二：循环方式

$array = [1,3,6,9,13,18,19,29,38,47,51,56,58,59,60,63,65,69,70,71,73,75,76,77,79,89];
$target = 73;
function bin_search($array, $target)

{
        $low = 0;
    $high = count($array)-1;
    $find = false;
    while (true){
        if ($low <= $high){
            var_dump($low, $high);echo "\n";
            $mid = intval(($low + $high)/2);
            if ($array[$mid] == $target){
                $find = true;
                break;
            } elseif ($array[$mid] < $target){
                    $low = $mid+1;
            } elseif ($array[$mid] > $target){
                   $high = $mid-1;
            }
        } else {
                break;
            }
    }
    return $find;
}
$find = bin_search($array, $target);
var_dump($find);

执行结果
int(0)
int(25)
int(13)
int(25)
int(20)
int(25)
int(20)
int(21)
bool(true)

我们看到，两种方式过程和结果相同。下面我们来测试下针对关联数组的二分查找算法：

$array = ['a'=>1,'b'=>3,'c'=>6,'d'=>9,'e'=>13,'f'=>18,'g'=>19,'h'=>29,'i'=>38];
$target = 19;
function bin_search($array, $target)
{
        $low = 0;
    $high = count($array)-1;
    $key_map = array_keys($array);
    $find = false;
    while (true){
        if ($low <= $high){
            var_dump($low, $high);echo "\n";
            $mid = intval(($low + $high)/2);
            if ($array[$key_map[$mid]] == $target){
                $find = true;
                break;
            } elseif ($array[$key_map[$mid]] < $target){
                    $low = $mid+1;
            } elseif ($array[$key_map[$mid]] > $target){
                    $high = $mid-1;
            }
        } else {
                break;
            }
    }
    return $find;
}
$find = bin_search($array, $target);
var_dump($find);

执行结果
int(0)
int(8)
int(5)
int(8)
bool(true)
两次二分查找，找到了$target，针对关联数组，我们使用了php的array_keys函数获得这个关联有序数组的key，通过key间接比对$target和$array的值。

以上就是PHP实现二分查找算法（代码详解）的详细内容

使用经验
若排序的记录数目n较小时，可以采用直接插入排序和简单选择排序，当记录本身信息量较大时，用简单选择排序方法较好。
若待排序记录按关键字基本有序，适合采用直接插入排序和冒泡排序。
若n值较大时，可以采用快速排序、堆排序和归并排序。另外快速排序被认为是内部排序方法中最好的方法。