快速排序(转)

int quicksort(vector<int> &v, int left, int right){
        if(left < right){
                int key = v[left];
                int low = left;
                int high = right;
                while(low < high){
                        while(low < high && v[high] > key){
                                high--;
                        }
                        v[low] = v[high];
                        while(low < high && v[low] < key){
                                low++;
                        }
                        v[high] = v[low];
                }
                v[low] = key;
                quicksort(v,left,low-1);
                quicksort(v,low+1,right);
        }
}

例： 排序[6  1  2  7  9  3  4  5 10  8]   h1 代表high值得第一次遍历到的位置    l1   low 的对应位置

key = 6  左边为参考值  则从右侧开始

1. 向左  6  1  2  7  9  3  4 5 10  8

h1 = 7    h1值 = 5

l1 = 0   l1值 = 6      h1 覆盖 l1 的值（上例v[low] = v[high];）    数组变为    5 1 2 7 9 3 4 5 10 8   

2. 向右  5 1 2 7 9 3 4 5 10 8

h2 = 7  h2值 = 5

l2 = 3  l2值 = 7    l2 覆盖 h2（v[high] = v[low];）    数组变为  5 1 2 7 9 3 4 7 10 8

3. 向左 5 1 2 7 9 3 4 7 10 8

h3 = 6   h3值 = 4

l3 = 3   l3值  = 7    h3 覆盖  l3      ====  5 1 2 4 9 3 4 7 10 8

4. 向右 5 1 2 4 9 3 4 7 10 8

h4 = 6   h4值 = 4

l4 = 4   l4值  = 9    l4 覆盖  h4      ====  5 1 2 4 9 3 9 7 10 8

5.向左 5 1 2 4 9 3 9 7 10 8

h5 = 5   h5值 = 3

l5 = 4   l5值  = 9    h5 覆盖  l5      ====  5 1 2 4 3 3 9 7 10 8

6. 向右 5 1 2 4 3 3 9 7 10 8

while(low < high && v[low] < key){

low++;
加一次后break

h6 = 5   h5值 = 3

l6 = 5  l6值  = 3       l6 不小于h6  跳出循环  

v[high] = v[low]; 后结果不变

5 1 2 4 3 3 9 7 10 8

 

while(low < high){不满足跳出循环

v[low] = key;

5 1 2 4 3 6 9 7 10 8

第一次排序完成       6 的左边都为小于6的数      右边都为大于6的数

 

继续递归排序   直到不满足条件退出  排序完成

 

这里left和right的值一般为数组的第一下标和最后下标      如   [1， 3， 4]    传参left = 0， right = 2

 

还有一种思路将参考值排除在排序之外，原理差不多

#include <stdio.h> 
int a[101],n;//定义全局变量，这两个变量需要在子函数中使用 
void quicksort(int left,int right) 
{ 
    int i,j,t,temp; 
    if(left>right) 
       return; 
                                
    temp=a[left]; //temp中存的就是基准数 
    i=left; 
    j=right; 
    while(i!=j) 
    { 
                   //顺序很重要，要先从右边开始找 
                   while(a[j]>=temp && i<j) 
                            j--; 
                   //再找右边的 
                   while(a[i]<=temp && i<j) 
                            i++; 
                   //交换两个数在数组中的位置 
                   if(i<j) 
                   { 
                            t=a[i]; 
                            a[i]=a[j]; 
                            a[j]=t; 
                   } 
    } 
    //最终将基准数归位 
    a[left]=a[i]; 
    a[i]=temp; 
                             
    quicksort(left,i-1);//继续处理左边的，这里是一个递归的过程 
    quicksort(i+1,right);//继续处理右边的 ，这里是一个递归的过程 
} 
int main() 
{ 
    int i,j,t; 
    //读入数据 
    scanf("%d",&n); 
    for(i=1;i<=n;i++) 
                   scanf("%d",&a[i]); 
    quicksort(1,n); //快速排序调用 
                             
    //输出排序后的结果 
    for(i=1;i<=n;i++) 
        printf("%d ",a[i]); 
    getchar();getchar(); 
    return 0; 
}