快速排序

快速排序原理:
       0    1   2    3   4    5    6     7
data   28   4   36   2   65   14   55    17
       Piv      i                         j
       left                             right

left.right 排序范围

Pivot为每次范围内的最左边数, data[left]
i = left;
j = right＋1;


1.从i+1位置往右寻找比Pivot大的数，得到索引i

2.从 j-1位置往左寻找比Pivot小的数，得到索引j

以上两个条件都严格边界，否则会产生无效运算

3.
如果i < j
则
    data[i],data[j]交换

如果i < j，跳到第1步

4.
如果 i>= j 并且j != left
则
   data[k],data[j]交换

到这步就产生了以Pivot为分界的两段数据，递归对两端数据进行1－4步运算

比如:

初始i = 0;j=8;

       0    1   2    3   4    5    6     7    8
data   28   4   36   2   65   14   55    17
       Piv      i                             j
       left                             right

第一趟
(1)
i = 2;
j = 7;
i < j,交换
       0    1   2    3   4    5    6     7
data   28   4   17   2   65   14   55    36
       Piv      i                         j
       left                             right
(2)
从i＝3开始继续找>Pivot的数
       0    1   2    3   4    5    6     7
data   28   4   17   2   65   14   55    36
       Piv               i     j         
       left                             right
从 j＝6开始继续找<Pivot的数

i = 4
j = 5
i< j,交换
       0    1   2    3   4    5    6     7
data   28   4   17   2   14   65   55    36
       Piv                              
       left                             right
(3)
从i = 5, j = 4开始继续找
       0    1   2    3   4    5    6     7
data   28   4   17   2   14   65   55    36
       Piv           j              i          
       left                             right

i = 6
j = 4
i > j
把28换到j位置
       0    1   2    3   4    5    6     7
data   14   4   17   2   28   65   55    36
       Piv                j         i          
       left                             right

现在分成两段

[14 4 17 2] 28 [65 55 36]
递归下去，退出条件是left < right

1. void Output(int array[], int n)
2. {
3.     printf("%d:/t/t ", count++);
4.     for (int i=0; i<n; i++)
5.     {
6.         printf("%d ", array[i]);
7.     }
8.     printf("/n");
9. }
11. void swap(int &a, int &b)
12. {
13.     printf("%d <- -> %d/n", a, b);
14.     int temp;
15.     temp = b;
16.     b = a;
17.     a = temp;
18. }
20. void QuickSort(int array[], int n, int left, int  right)
21. {
22.     int Pivot = array[left];
23.     int i = left;
24.     int j = right+1;
26.     if (left < right)
27.     {
28.         printf("new turn/n");
29.         while (i < j)
30.         {
31.             // 从+1位置找比Pivot大的
32.             do
33.             {
34.                 i++;
35.                 printf("i = %d/n", i);
36.             }while (array[i] <= Pivot && i < right);
38.             // 从最右边位置找比Pivot小的  
39.             do
40.             {
41.                 j--;
42.                 printf("j = %d/n", j);
43.             }while (array[j] >= Pivot && j > left);
44.                         
45.             // i < j,调整左右两边
46.             if (i < j)
47.             {
48.                 swap(array[i], array[j]);
49.                 Output(array, n);
50.             }
51.         }
53.         // i >=j 已经调整好，Pivot放置到中间值,如果j已经和left相等,那么不必再动位置了
54.         if (i >= j && j != left)
55.         {
56.             swap(array[left], array[j]);
57.             Output(array, n);
58.         }
60.         QuickSort(array, n, left, j-1);
61.         QuickSort(array, n, j+1, right);
62.     }
63. }

为了消除冗余计算，每次取i++, j--可达到目的