快速排序【记录一下代码】

本文仅用作学习记录，大神勿喷O(∩_∩)O~

代码一、百度百科C++语言版本代码,参考数据结构p274(清华大学出版社，严蔚敏)

void Qsort1(int a[], int low, int high)//百度百科C++语言版本代码 
{/*参考数据结构p274(清华大学出版社，严蔚敏)*/
    if(low >= high) return;
    int first = low;
    int last = high;
    int key = a[first];/*用字表的第一个记录作为枢轴*/
 
    while(first < last)
    {
        while(first < last && a[last] >= key)
        {
            --last;
        }
        a[first] = a[last];/*将比第一个小的移到低端*/
        while(first < last && a[first] <= key)
        {
            ++first;
        }
        a[last] = a[first];    
        /*将比第一个大的移到高端*/
    }
    a[first] = key;/*枢轴记录到位*/
    Qsort1(a, low, first-1);
    Qsort1(a, first+1, high);
}

代码二、百度百科C语言版本代码

void Qsort2(int *a, int left, int right)//百度百科C语言版本代码 
{
    if(left >= right)/*如果左边索引大于或者等于右边的索引就代表已经整理完成一个组了*/
    {
        return ;
    }
    int i = left;
    int j = right;
    int key = a[left];
     
    while(i < j)                               /*控制在当组内寻找一遍*/
    {
        while(i < j && key <= a[j])/*而寻找结束的条件就是，1，找到一个小于或者大于key的数（大于或小于取决于你想升序还是降序）2，没有符合条件1的，并且i与j的大小没有反转*/ 
        {
            j--;/*向前寻找*/
        }
        a[i] = a[j];/*找到一个这样的数后就把它赋给前面的被拿走的i的值（如果第一次循环且key是a[left]，那么就是给key）*/
         
        while(i < j && key >= a[i])/*这是i在当组内向前寻找，同上，不过注意与key的大小关系停止循环和上面相反，因为排序思想是把数往两边扔，所以左右两边的数大小与key的关系相反*/
        {
            i++;
        }
        a[j] = a[i];
    }
     
    a[i] = key;/*当在当组内找完一遍以后就把中间数key回归*/
    Qsort2(a, left, i - 1);/*最后用同样的方式对分出来的左边的小组进行同上的做法*/
    Qsort2(a, i + 1, right);/*用同样的方式对分出来的右边的小组进行同上的做法*/
                       /*当然最后可能会出现很多分左右，直到每一组的i = j 为止*/
}

代码三、坐在马桶上看算法：快速排序。   链接：http://developer.51cto.com/art/201403/430986.htm

（来源页面评论代码有误，测试没发现问题。）

void Qsort3(int a[],int left,int right) //坐在马桶上看算法：快速排序。http://developer.51cto.com/art/201403/430986.htm 
{ 
    int i,j,t,temp; 
    if(left>right) return; 
                                
    temp=a[left]; //temp中存的就是基准数 
    i=left; 
    j=right; 
    while(i!=j) 
    { 
        //顺序很重要，要先从右边开始找 
        while(i<j && a[j]>=temp) 
            j--; 
        //再找右边的 
        while(i<j && a[i]<=temp) 
            i++; 
        //交换两个数在数组中的位置 
        if(i<j) 
        { 
            t=a[i]; a[i]=a[j]; a[j]=t; 
        } 
    } 
    //最终将基准数归位 
    a[left]=a[i]; 
    a[i]=temp; 
                             
    Qsort3(a,left,i-1);//继续处理左边的，这里是一个递归的过程 
    Qsort3(a,i+1,right);//继续处理右边的 ，这里是一个递归的过程 
}

代码四、白话经典算法系列之六 快速排序   链接： http://blog.csdn.net/morewindows/article/details/6684558#

链接页面评论一致认为作者讲解非常棒。

void Qsort4(int s[], int l, int r)//白话经典算法系列之六 快速排序 http://blog.csdn.net/morewindows/article/details/6684558#
{  
    if (l < r)  
    { 
        int i = l, j = r, x = s[l];
        while (i < j)
        {
            while(i < j && s[j] >= x) // 从右向左找第一个小于x的数  
                j--;    
            if(i < j)   
                s[i++] = s[j];  
              
            while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数  
                i++;    
            if(i < j)   
                s[j--] = s[i];  
        }
        s[i] = x;  
        Qsort4(s, l, i - 1); // 递归调用   
        Qsort4(s, i + 1, r);  
    }
}  

代码五、博客园~大器晚成~的代码  链接：http://www.cnblogs.com/luchen927/archive/2012/02/29/2368070.html

原文代码有误，评论里面已经有园友指出。这里摘抄时已经修改，否则当待排序列有相等值则可能会死循环 。

void Qsort5(int *v, int left, int right)//博客园“大器晚成”的代码http://www.cnblogs.com/luchen927/archive/2012/02/29/2368070.html 
{//原文代码有错误，已经修改，否则当待排序列有相等值则会死循环 。修改以后，本代码与百度百科代码是相同 
    if(left < right)
    {
        int key = v[left];
        int low = left;
        int high = right;
        while(low < high)
        {
            while(low < high && v[high] >= key)//原文 while(low < high && v[high] > key)
            {
                high--;
            }
            v[low] = v[high];
            while(low < high && v[low] <= key)//原文while(low < high && v[low] < key)
            {
                low++;
            }
            v[high] = v[low];
        }
        v[low] = key;
        Qsort5(v,left,low-1);
        Qsort5(v,low+1,right);
    }
}

代码六、《C++一本通》page191快速排序代码（请阅读这一段代码）

void Qsort6(int *a,int l,int r)//《C++一本通》page191快速排序代码 
{  
    int i,j,mid,p;
    i=l;
    j=r; 
    mid=a[(l+r) / 2]; //将当前序列在中间位置的数定义为分隔数
    do
    {
        while (a[i]<mid) i++;//在左半部分寻找比中间数大的数
        while (a[j]>mid) j--;//在右半部分寻找比中间数小的数
        if (i<=j) 
        { //若找到一组与排序目标不一致的数对则交换它们
            p=a[i];a[i]=a[j];a[j]=p;
            i++;j--; //继续找
        }
    }while(i<=j);//注意这里不能少等号
    if (l<j)  Qsort6(a,l,j);//若未到两个数的边界，则递归搜索左右区间
    if (i<r)  Qsort6(a,i,r);
}

代码七、来自北大郭炜老师在网易云课堂开设的算法课程

#include <iostream>
using namespace std;
void swap(int & a,int & b) //交换变量a,b值
{
    int tmp = a;
    a = b;
    b = tmp;
}
void QuickSort(int a[],int s,int e)
{
    if( s >= e) return;
    int k = a[s];
    int i = s,j = e;
    while( i != j ) 
    {
        while( j > i && a[j] >= k ) --j;
        swap(a[i],a[j]);
        while( i < j && a[i] <= k ) ++i;
        swap(a[i],a[j]);
    } //处理完后， a[i] = k
    QuickSort(a,s,i-1);
    QuickSort(a,i+1,e);
}
int a[] = { 93,27,30,2,8,12,2,8,30,89};
int main()
{
    int size = sizeof(a)/sizeof(int);
    QuickSort(a,0,size-1);
    for(int i = 0;i < size; ++i)
        cout << a[i] << ",";
    cout << endl;
    return 0;
}

 

 

注意：在快排过程中划分区间时，必须要有等号，比如：

    int i=left,j=right,key=a[left];
    while(i<j)
    {
        while(i<j&&key>=a[j]) j--;//必须取等号，否则当数组两头的数相等时会死循环 
        a[i]=a[j];
        while(i<j&&key<=a[i]) i++;//必须取等号，否则当数组两头的数相等时会死循环
        a[j]=a[i];
    }

这种地方>=不能改为>，否则可能死循环。

 

 

 

测试用的主函数

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

int cmp(const void *a,const void *b)
{    return *(int*)a - *(int*)b;   }
int main()
{
    int a[50],b[50],c[50],d[50],e[50],f[50],g[50],h[50];
    int n,i,k=100000,index=1,count=0;
    srand((unsigned)time(0));
    
    freopen("res.out","w",stdout);
    for(;k>0;k--)
    {
        n=(rand()%2==1?49:50);
         for(i=0;i<n;i++)
         {
             a[i]=rand()%3000;
             h[i]=g[i]=f[i]=e[i]=d[i]=c[i]=b[i]=a[i];
        }
        
        Qsort1(a, 0, n - 1);
        Qsort2(b, 0, n - 1);
         qsort(c,n,sizeof(c[0]),cmp);
         Qsort3(e,0,n-1);
         Qsort4(f,0,n-1);
         Qsort5(g,0,n-1);
         Qsort6(h,0,n-1);
         
        for(i= 0; i < n; i++)
        {
            if(a[i]!=c[i]||b[i]!=c[i]||e[i]!=c[i]||f[i]!=c[i]||g[i]!=c[i]||h[i]!=c[i]) 
                break;
        }
        if(i<n)
        {
            printf("case %d:\n",index);
            printf("A:");//Qsort1的结果 
            for(i=0;i<n;i++)
                printf("%d ",a[i]);
               printf("\n");
               
               printf("B:");//Qsort2的结果 
            for(i=0;i<n;i++)
                printf("%d ",b[i]);
               printf("\n");
               
               printf("C:");//标准结果序列 
            for(i=0;i<n;i++)
                printf("%d ",c[i]);
               printf("\n");
               
               printf("E:");//Qsort3的结果 
            for(i=0;i<n;i++)
                printf("%d ",e[i]);
               printf("\n");
               
               printf("F:");//Qsort4的结果 
            for(i=0;i<n;i++)
                printf("%d ",f[i]);
               printf("\n");
               
               printf("G:");//Qsort5的结果 
            for(i=0;i<n;i++)
                printf("%d ",g[i]);
               printf("\n");
               
               printf("H:");//Qsort6的结果 
            for(i=0;i<n;i++)
                printf("%d ",h[i]);
               printf("\n");
               
               printf("D:");//原未排序序列 
            for(i=0;i<n;i++)
                printf("%d ",d[i]);
               printf("\n");
        }
        else { printf("case %d is ok!\n",index); count++;}
        index++;
    }
    printf("%d of %d is ok!\n",count,index-1);
    return 0;
}

 

其实 Qsort1、Qsort2、Qsort5（博客园代码修改以后）三份代码是一样的
Qsort4跟上面几个是差不多的，但稍有一点点改变
Qsort3思路变化比较大一些。
Qsort6简直就是另类代码风格，瞎搞的，不过也是对的。
学习记住 Qsort1、Qsort2、Qsort5之一或者Qsort4即可。

经过在洛谷OJ  P1177 测试，代码六应该是最合理的，大家还是记住代码六吧。。。。。。

（利用库函数qsort在洛谷OJ  P1177提交确实也是AC的，然后利用代码六去提交也可以过。说明OJ的数据没问题。）

其余代码的分割点元素的选择都是选第一个元素，这个决策是一个不合理的决策，会导致算法的时间复杂度在某些情况下变为N^2级别的。虽然代码六不能够完全避免这个情况，但是相对而言比较合理一些。具体论述请参考《数据结构与算法分析：C语言描述（原书第2版）》对快速排序的描述。