C++实现快速排序

转载：https://blog.csdn.net/AA2519556/article/details/77884962

快速排序的基本思想是：通过一趟排序将要排序的数据分割分类照片中翻译独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据进行分别快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

排序快速的英文一种不稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动

快速排序是CRAHoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，称其通常为分治行业释义法律（分而ConquerMethod）。

该方法的基本思想是：

1.数先从列中取出一个数作为基准数。

2.分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。

3.再对左右区间重复第二步，直到各区间只有一个数。

  

以一个数组作为示例，取区间第一个数为基准数。

0	1	2	3	4	五	6	7	8	9
72	6	57	88	60	42	83	73	48	85

初始时，i = 0; j = 9; X = a [i] = 72

由于已经将一个[0]中的数保存到X中，可以理解成在数组A [0]上挖了个坑，可以将其它数据填充到这来。

从Ĵ开始向前找一个比X小或等于X的数。当J = 8，符合条件，将一个[8]挖出再填到上一个坑一个[0]中。一个[0] = A [ 8];我++; 这样一个坑一个[0]就被搞定了，但又形成了一个新坑一个[8]，这怎么办了？简单，再找数字来填一个[8]这个坑。这次从我开始向后找一个大于X的数，当I = 3，符合条件，将[3]挖出再填到上一个坑中一个[8] = [3]; j--;

 

数组变为：

0	1	2	3	4	五	6	7	8	9
48	6	57	88	60	42	83	73	88	85

 我= 3; j = 7; X = 72

再重复上面的步骤，先从后向前找，再从前向后找。

从j开始向前找，当j = 5，符合条件，将a [5]挖出填到上一个坑中，a [3] = a [5]; 我++;

从我开始向后找，当I = 5时，由于我==Ĵ退出。

此时，i = j = 5，而a [5]刚好又是上次挖的坑，因此将X填入a [5]。

 

数组变为：

0	1	2	3	4	五	6	7	8	9
48	6	57	42	60	72	83	73	88	85

可以看出一个[5]前面的数字都小于它，一个[5]后面的数字都大于它。因此再对一个[0 ... 4]和A [6 ... 9]这二个子区间重复上述步骤就可以了。

 

 

对挖坑填数进行总结

1.i = L; j = R; 将基准数挖出形成第一个坑一个[i]中。

2.j--由后向前找比它小的数，找到后挖出此数填前一个坑A [1]中。

3.I ++由前向后找比它大的数，找到后也挖出此数填到前一个坑一个[J]中。

4.再重复执行2,3-二步，直到我==Ĵ，将基准数填入一个[I]中。

代码如下：

[cpp]   查看纯 文本  

1. 的#include <iostream的>  
2. 使用namespace  std;   
3. void  quickSort（int  a []，int ，int ）;  
4. int  main（）  
5. {  
6.     int  array [] = {34,65,12,43,67,5,78,10,3,70}，k;  
7.     int  len = sizeof （array）/ sizeof （int ）;  
8.     cout << “原始数组：” << endl;  
9.     for （k = 0; k <len; k ++）  
10.         cout << array [k] << “，” ;  
11.     COUT << ENDL;  
12.     快速排序（阵列，0，LEN-1）;  
13.     cout << “排序后的数组：” << endl;  
14.     for （k = 0; k <len; k ++）  
15.         cout << array [k] << “，” ;  
16.     COUT << ENDL;  
17.     系统（“暂停” ）;  
18.     返回 0;  
19. }  
20.   
21. void  quickSort（int  s []，  int  l，  int  r）  
22. {  
23.     如果 （1 <r）  
24.     {        
25.         int  i = 1，j = r，x = s [l];  
26.         而 （i <j）  
27.         {  
28.             while （i <j && s [j]> = x）  //从右向左找第一个小于x的数  
29.                 j--;   
30.             如果（i <j）  
31.                 s [i ++] = s [j];  
32.             while （i <j && s [i] <x）  //从左向右找第一个大于等于x的数  
33.                 我++;   
34.             如果（i <j）  
35.                 s [j--] = s [i];  
36.         }  
37.         s [i] = x;  
38.         quickSort（s，l，i - 1）; //递归调用  
39.         quickSort（s，i + 1，r）;  
40.     }  
41. }  

原文地址：HTTP：//blog.sina.com.cn/s/blog_5c5bc9070100y4zv.html