快速排序

假设要排序的数组是A[1]……A[N]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一躺快速排序。一躺快速排序的算法是：

   1）、设置两个变量I、J，排序开始的时候I：=1，J：=N；

   2）以第一个数组元素作为关键数据，赋值给X，即X：=A[1]；

   3）、从J开始向前搜索，即由后开始向前搜索（J：=J-1），找到第一个小于X的值，两者交换；

   4）、从I开始向后搜索，即由前开始向后搜索（I：=I+1），找到第一个大于X的值，两者交换；

   5）、重复第3、4步，直到I=J；

   例如：待排序的数组A的值分别是：（初始关键数据X：=49）

                   A[1]     A[2]     A[3]     A[4]     A[5]      A[6]     A[7]：

                     49        38       65       97       76       13        27

进行第一次交换后：   27        38       65       97       76       13        49

                   ( 按照算法的第三步从后面开始找

进行第二次交换后：   27        38       49       97       76       13        65

                  ( 按照算法的第四步从前面开始找>X的值，65>49,两者交换，此时I：=3 )

进行第三次交换后：   27        38       13       97       76       49        65

( 按照算法的第五步将又一次执行算法的第三步从后开始找

进行第四次交换后：   27        38       13       49       76       97        65

( 按照算法的第四步从前面开始找大于X的值，97>49,两者交换，此时J：=4 )

      此时再执行第三不的时候就发现I=J，从而结束一躺快速排序，那么经过一躺快速排序之后的结果是：27        38       13       49       76       97        65，即所以大于49的数全部在49的后面，所以小于49的数全部在49的前面。

 

  

   

    [cpp] 
    view plain
    copy
    print
    ?
    

   
  
  
#include <stdio.h>  
#include <stdlib.h>  
  
// #define SWAP(a,b) \  
//                  {\  
//                  (a) = (a) ^(b);(b) = (b) ^ (a);(a) = (a) ^ (b);\  
//                  }  
  
void swap(int *a, int *b)  
{  
    int tmp;  
    tmp = *a;  
    *a = *b;  
    *b = tmp;  
}  
  
int partition(int * arr,int left,int right)  
{  
    int pivotkey;  
  
    pivotkey = arr[left];  
    while(left<right)  
    {     
        // 从右往左找，比关键字小的值，交换后right指向关键字  
        while(left<right && arr[right]>=pivotkey) right--;  
//      SWAP(arr[left],arr[right]);  
        swap(&arr[left],&arr[right]);  
        //从左边找，比关键字大的值，交换后left指向关键字  
        while(left<right && arr[left]<=pivotkey) left++;  
        swap(&arr[left],&arr[right]);  
//      SWAP(arr[left],arr[right]);  
    }  
    return left;  
}  
  
void qSort(int * arr, int left, int right)  
{  
    int par;  
    if (left<right)  
    {  
        par = partition(arr,left,right);  
        qSort(arr,left,par-1);  
        qSort(arr,par+1,right);  
    }  
}  
  
void quickSort(int *arr,int size)  
{  
    qSort(arr,0,size-1);  
}  
  
void print(int *arr,int size)  
{  
    int i;  
  
    for (i = 0; i < size; ++i)  
    {  
        printf("%d ",arr[i]);  
    }  
    printf("\n");  
}  
  
int main(int argc, char const *argv[])  
{  
    int arr[] = {2,3,4,1,5,8,6,10,9,7};  
    int size = sizeof(arr)/sizeof(arr[0]);  
    quickSort(arr,size);  
    print(arr,size);  
    return 0;  
}  
 
//方法二

 

  

   

    [cpp] 
    view plain
    copy
    print
    ?
    

   
  
  
#include <stdio.h>  
#include <stdlib.h>  
  
// #define SWAP(a,b) \  
//                  {\  
//                  (a) = (a) ^(b);(b) = (b) ^ (a);(a) = (a) ^ (b);\  
//                  }  
  
void swap(int *a, int *b)  
{  
    int tmp;  
    tmp = *a;  
    *a = *b;  
    *b = tmp;  
}  
  
int partition(int * arr,int left,int right)  
{  
    int pivotkey;  
    int temp;  
    pivotkey = arr[left];  
    temp = pivotkey;  
    while(left<right)  
    {     
        // 从右往左找，比关键字小的值，交换后right指向关键字  
        while(left<right && arr[right]>=pivotkey) right--;  
//      SWAP(arr[left],arr[right]);  
//      swap(&arr[left],&arr[right]);  
        arr[left] = arr[right];  
        //从左边找，比关键字大的值，交换后left指向关键字  
        while(left<right && arr[left]<=pivotkey) left++;  
//      swap(&arr[left],&arr[right]);  
//      SWAP(arr[left],arr[right]);  
        arr[right] = arr[left];  
    }  
    arr[left] = temp;  
    return left;  
}  
  
void qSort(int * arr, int left, int right)  
{  
    int par;  
    if (left<right)  
    {  
        par = partition(arr,left,right);  
        qSort(arr,left,par-1);  
        qSort(arr,par+1,right);  
    }  
}  
  
void quickSort(int *arr,int size)  
{  
    qSort(arr,0,size);  
}  
  
void print(int *arr,int size)  
{  
    int i;  
  
    for (i = 0; i < size; ++i)  
    {  
        printf("%d ",arr[i]);  
    }  
    printf("\n");  
}  
  
int main(int argc, char const *argv[])  
{  
    int arr[] = {2,3,4,1,5,8,6,10,9,7};  
    int size = sizeof(arr)/sizeof(arr[0]);  
    quickSort(arr,size);  
    print(arr,size);  
    return 0;  
}