归并和快速排序思想的延伸

Posted 番茄技术小栈

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了归并和快速排序思想的延伸相关的知识，希望对你有一定的参考价值。

了解归并和快速排序算法背后的算法思想：分治思想，并对归并和快速排序进行扩展，解决经典算法问题：逆序对和第K大的算法问题

分治算法

顾名思义，分而治之，就是将原问题，分割成同等结构的子问题，之后将子问题逐一解决后，原问题也就得到了解决。

归并排序算法的延伸：逆序对

什么是逆序对？

对于一个长度为N的整数序列A，满足i < j 且 Ai > Aj.的数对(i,j)称为整数序列A的一个逆序。 通常逆序对可以表示一个数列的顺序程度，从小到大的数列逆序对为0，从大到小的逆序对为：(n*(n-1))/2;

分析

采用分而治之的思想，要求整个数列的逆序对，可以先求出前一半数列的逆序对，和后一半数列的逆序对，然后加上前一个数列和后一个数列所形成的逆序对，因为前后两个数列都是有序，直接在归并排序merge的时候求是非常简单的。

代码实现

 
   
   
 
    
  
    
    
  
  1. function merge(&$arr, $l, $mid, $r){
    2. 
  
    
    
  
  2.     $tmp = array();
    3. 
  
    
    
  
  3.     $tmp = array_slice($arr, $l, $r-$l+1, true);
    4. 
  
    
    
  
    5. 
  
    
    
  
  5.     $res = 0;
    6. 
  
    
    
  
  6.     //tmp现在为$arr的副本，以tmp为轴，重新赋值$arr
    7. 
  
    
    
  
  7.     $i = $l;
    8. 
  
    
    
  
  8.     $j = $mid+1;
    9. 
  
    
    
  
  9.     for ($k=$l; $k <= $r; $k++) {
    10. 
  
    
    
  
  10.         if ($i > $mid) {
    11. 
  
    
    
  
  11.             $arr[$k] = $tmp[$j];
    12. 
  
    
    
  
  12.             $j++;
    13. 
  
    
    
  
  13.         }elseif ($j > $r) {
    14. 
  
    
    
  
  14.             $arr[$k] = $tmp[$i];
    15. 
  
    
    
  
  15.             $i++;
    16. 
  
    
    
  
  16.         }elseif($tmp[$i] <= $tmp[$j]){
    17. 
  
    
    
  
  17.             $arr[$k] = $tmp[$i];
    18. 
  
    
    
  
  18.             $i++;
    19. 
  
    
    
  
  19.         }else{
    20. 
  
    
    
  
  20.             // 此时, 因为右半部分k所指的元素小
    21. 
  
    
    
  
  21.             // 这个元素和左半部分的所有未处理的元素都构成了逆序数对
    22. 
  
    
    
  
  22.             // 左半部分此时未处理的元素个数为 $mid - $i + 1;
    23. 
  
    
    
  
  23.             $res += $mid - $i + 1;
    24. 
  
    
    
  
  24.             $arr[$k] = $tmp[$j];
    25. 
  
    
    
  
  25.             $j++;
    26. 
  
    
    
  
  26.         }
    27. 
  
    
    
  
  27.     }
    28. 
  
    
    
  
  28.     return $res;
    29. 
  
    
    
  
  29. }
    30. 
  
    
    
  
    31. 
  
    
    
  
    32. 
  
    
    
  
  32. /**
    33. 
  
    
    
  
  33.  * [__mergeSort 对区间为[l,r]的元素进行归并排序]
    34. 
  
    
    
  
  34.  * @param  [type] $arr [description]
    35. 
  
    
    
  
  35.  * @param  [type] $l   [description]
    36. 
  
    
    
  
  36.  * @param  [type] $r   [description]
    37. 
  
    
    
  
  37.  * @return [type]      [description]
    38. 
  
    
    
  
  38.  */
    39. 
  
    
    
  
  39. function __inversionCount(&$arr, $l, $r){
    40. 
  
    
    
  
  40.     //此时为一个元素，不需要进行归并
    41. 
  
    
    
  
  41.     if ($l >= $r) {
    42. 
  
    
    
  
  42.         return 0;
    43. 
  
    
    
  
  43.     }
    44. 
  
    
    
  
    45. 
  
    
    
  
    46. 
  
    
    
  
  46.     $mid = (int)(($l + $r) / 2);
    47. 
  
    
    
  
  47.     // 求出 arr[l...mid] 范围的逆序数
    48. 
  
    
    
  
  48.     $res1 = __inversionCount($arr, $l, $mid);
    49. 
  
    
    
  
  49.     // 求出 arr[mid+1...r] 范围的逆序数
    50. 
  
    
    
  
  50.     $res2 = __inversionCount($arr, $mid+1, $r);
    51. 
  
    
    
  
    52. 
  
    
    
  
  52.     return $res1 + $res2 + merge($arr, $l, $mid, $r);
    53. 
  
    
    
  
  53. }
    54. 
  
    
    
  
    55. 
  
    
    
  
    56. 
  
    
    
  
  56. function inversionCount(&$arr, $n){
    57. 
  
    
    
  
  57.     $res = __inversionCount($arr, 0, $n-1);
    58. 
  
    
    
  
  58.     return $res;
    59. 
  
    
    
  
  59. }
    60.

结果

 
   
   
 
    
  
    
    
  
  1. Array
    2. 
  
    
    
  
  2. (
    3. 
  
    
    
  
  3.     [0] => 3
    4. 
  
    
    
  
  4.     [1] => 0
    5. 
  
    
    
  
  5.     [2] => 5
    6. 
  
    
    
  
  6.     [3] => 5
    7. 
  
    
    
  
  7.     [4] => 8
    8. 
  
    
    
  
  8.     [5] => 0
    9. 
  
    
    
  
  9.     [6] => 8
    10. 
  
    
    
  
  10.     [7] => 5
    11. 
  
    
    
  
  11. )
    12. 
  
    
    
  
  12. 逆序对的个数: 7
    13.

快速排序算法的延伸：数列中第k大的数

分析

  • 解法1： 我们可以对这个乱序数组按照从大到小先行排序，然后取出前k大，总的时间复杂度为O(n*logn + k)。

  • 解法2： 利用选择排序或交互排序，K次选择后即可得到第k大的数。总的时间复杂度为O(n*k)

  • 解法3： 利用快速排序的思想，从数组S中随机找出一个元素X，把数组分为两部分Sa和Sb。Sa中的元素大于等于X，Sb中元素小于X。这时有两种情况：

  • Sa中元素的个数小于k，则Sb中的第k-|Sa|个元素即为第k大数；

  • Sa中元素的个数大于等于k，则返回Sa中的第k大数。时间复杂度近似为O(n)

这里我们采用第三种解法，时间复杂度为:O(n)+O(1/2)+O(1/4)+...+O(1/n)， 当n为无穷大时候，时间复杂度约为O(n)

代码实现

 
   
   
 
    
  
    
    
  
  1. //对arr[l...r]部分进行partition操作
    2. 
  
    
    
  
  2. // 返回p,使得arr[l...p-1] < arr[p] ; arr[p+1...r] > arr[p]
    3. 
  
    
    
  
  3. function partition(&$arr, $l, $r){
    4. 
  
    
    
  
    5. 
  
    
    
  
  5.     swap($arr, $l, rand($l, $r));
    6. 
  
    
    
  
    7. 
  
    
    
  
  7.     $v = $arr[$l];
    8. 
  
    
    
  
  8.     $j = $l;
    9. 
  
    
    
  
    10. 
  
    
    
  
  10.     for ($i=$l+1; $i <= $r ; $i++) { 
    11. 
  
    
    
  
  11.         if ($arr[$i] < $v) {
    12. 
  
    
    
  
  12.             swap($arr, $j+1, $i);
    13. 
  
    
    
  
  13.             $j++;
    14. 
  
    
    
  
  14.         }
    15. 
  
    
    
  
  15.     }
    16. 
  
    
    
  
  16.     swap($arr, $l, $j);
    17. 
  
    
    
  
  17.     return $j;
    18. 
  
    
    
  
  18. }
    19. 
  
    
    
  
    20. 
  
    
    
  
  20. /**
    21. 
  
    
    
  
  21.  * [__quickSort 对数组arr[l...r]进行快速排序]
    22. 
  
    
    
  
  22.  * @param  [type] &$arr [description]
    23. 
  
    
    
  
  23.  * @param  [type] $l    [description]
    24. 
  
    
    
  
  24.  * @param  [type] $r    [description]
    25. 
  
    
    
  
  25.  * @return [type]       [description]
    26. 
  
    
    
  
  26.  */
    27. 
  
    
    
  
  27. function __selectK(&$arr, $l, $r, $k){
    28. 
  
    
    
  
  28.     if ($l == $r) {
    29. 
  
    
    
  
  29.         return $arr[$l];
    30. 
  
    
    
  
  30.     }
    31. 
  
    
    
  
    32. 
  
    
    
  
  32.     // 如果 k == p, 直接返回arr[p]
    33. 
  
    
    
  
  33.     $p = partition($arr, $l, $r, $k);
    34. 
  
    
    
  
  34.     if ($p == $k) {
    35. 
  
    
    
  
  35.         return $arr[$p];
    36. 
  
    
    
  
  36.     }elseif($p > $k){// 如果 k < p, 只需要在arr[l...p-1]中找第k小元素即可
    37. 
  
    
    
  
  37.         return __selectK($arr, $l, $p-1, $k);
    38. 
  
    
    
  
  38.     }else{// 如果 k > p, 则需要在arr[p+1...r]中找第k小元素
    39. 
  
    
    
  
  39.         return __selectK($arr, $p+1, $r, $k);
    40. 
  
    
    
  
  40.     }
    41. 
  
    
    
  
  41. }
    42. 
  
    
    
  
    43. 
  
    
    
  
  43. // 寻找arr数组中第k小的元素
    44. 
  
    
    
  
  44. function selectK(&$arr, $n, $k){
    45. 
  
    
    
  
  45.     assert($k >= 0 && $k <= $n);
    46. 
  
    
    
  
  46.     return __selectK($arr, 0, $n-1, $k);
    47. 
  
    
    
  
  47. }
    48.

结果

 
   
   
 
    
  
    
    
  
  1. Array
    2. 
  
    
    
  
  2. (
    3. 
  
    
    
  
  3.     [0] => 9
    4. 
  
    
    
  
  4.     [1] => 4
    5. 
  
    
    
  
  5.     [2] => 10
    6. 
  
    
    
  
  6.     [3] => 4
    7. 
  
    
    
  
  7.     [4] => 7
    8. 
  
    
    
  
  8.     [5] => 6
    9. 
  
    
    
  
  9.     [6] => 3
    10. 
  
    
    
  
  10.     [7] => 10
    11. 
  
    
    
  
  11.     [8] => 7
    12. 
  
    
    
  
  12.     [9] => 9
    13. 
  
    
    
  
  13. )
    14. 
  
    
    
  
  14. 第3小的数为: 6
    15.


以上是关于归并和快速排序思想的延伸的主要内容，如果未能解决你的问题，请参考以下文章

C++ 随机化快速排序 最简单易懂的代码！ 基于归并分区思想实现

算法笔记 7 归并排序和快速排序

算法排序02——归并排序介绍及其在分治算法思想上与快排的区别（含归并代码）

排序算法中——归并排序和快速排序

算法链表的快速排序和归并排序

算法链表的快速排序和归并排序