算法学习记录-排序——快速排序

快速排序

快速排序由图灵奖获得者Tony Hoare26岁设计出来，这个大牛有兴趣的可以google下。

前面讲过 直接插入排序、简单选择排序、冒泡排序 这几个我们能够最直接想出来的排序方法。（时间复杂度都是 O(N²⁾）

后来人们一直寻找能够打破时间复杂度O(N²)的限制。

先后有 希尔排序，它是直接插入排序的升级。（每趟插入的步长从大到小）

堆排序，它是简单选择排序的升级。（应用堆这个结构来存储数据的大小关系）

而快速排序则是冒泡排序的升级。（冒泡排序是比较两个相邻的数大小，交换）

快速排序：

基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，

其中一部分的所有数据都比另外一部分的所有数据都要小，

然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

看完了有没有看懂？或者有没感觉到它确实比其他算法快？

1.通过一趟排序，将待排的数据分成两个部分。保证前一部分比后一部分都要小。

2.然后对这分出来的 两部分 进行同样的操作。（这里就有一个递归额思想）

严蔚敏书上对一次快速排序定义

假设待排的序列｛r1,r2,r3,rn｝,首先任意选取一个记录（通常可选择第一个记录r1）作为枢轴（pivot），

然后按下述原则重新排列其余记录：

将所有关键字较pivot的记录小的安置在它的前面，

将所有关键字教pivot的记录大的安置在它的后面。之后，可以将该piovt记录最后的位置i作为分界线，

最后这个序列就变成了 {{r1,r2...ri-1}{ri}{ri+1,ri+2...rn}};

具体piovt是怎么操作的，我们看下面的图：

算法：
1.初始化的时候，pivot和low指向同一个记录。low定位了poivt，high指针活动。
2.high初试指向最末尾一个记录，比较high指针的记录是否不小于poivt记录，若不小于，则high指针就减少一个，指向前一个记录，再次与poivt比较，直到有一个记录小于poivt的记录，这个时候就交换low和high的记录数。（也是poivt与high交换），同时high就定位poivt，low开始活动。
3.同理，low与poivt（也就是high指向的记录）比较，若low不大于poivt记录，则low就指向后一个元素，直到有一个记录大于poivt，则交换low和high（poivt）的记录，同时poivt又由low定位了。
4.依次类推，直到low不小于high，返回low的值，这个就是我们划分的位置 

 

 程序：

//***********************quickSort*******************************//

int getpiovtPos(myDataType *ary,int low,int high)
{
    int poivtVal = ary[low];
    myDataType temp;

    while(low < high)
    {
        while(low < high && ary[high] >= poivtVal)
        {
            high--;
        }
        //交换
        temp = ary[low];
        ary[low] = ary[high];
        ary[high]=temp;

        while(low < high && ary[low] <= poivtVal)
        {
            low++;
        }
        //交换
        temp = ary[low];
        ary[low] = ary[high];
        ary[high]=temp;
    }
    return low;
}
void QSort(myDataType *ary,int low,int high)
{
    int poivt;
    if (low < high)
    {
        poivt = getpiovtPos(ary,low,high);

        QSort(ary,low,poivt-1);
        QSort(ary,poivt+1,high);
    }
}
void quickSort(myDataType *ary,int len)
{
    QSort(ary,0,len-1);
}

完整代码：

typedef int myDataType;
//myDataType src_ary[10] = {9,1,5,8,3,7,6,0,2,4};
//myDataType src_ary[10] = {1,2,3,4,5,6,7,8,9,10};
myDataType src_ary[10] = {10,9,8,7,6,5,4,3,2,1};
void prt_ary(myDataType *ary,int len)
{
    int i=0;
    while(i < len)
    {
        printf(" %d ",ary[i++]);
    }
    printf("
");
}
//***********************quickSort*******************************//

int getpiovtPos(myDataType *ary,int low,int high)
{
    int poivtVal = ary[low];
    myDataType temp;

    while(low < high)
    {
        while(low < high && ary[high] >= poivtVal)
        {
            high--;
        }
        //交换
        temp = ary[low];
        ary[low] = ary[high];
        ary[high]=temp;

        while(low < high && ary[low] <= poivtVal)
        {
            low++;
        }
        //交换
        temp = ary[low];
        ary[low] = ary[high];
        ary[high]=temp;
    }
    return low;
}
void QSort(myDataType *ary,int low,int high)
{
    int poivt;
    if (low < high)
    {
        poivt = getpiovtPos(ary,low,high);

        QSort(ary,low,poivt-1);
        QSort(ary,poivt+1,high);
    }
}
void quickSort(myDataType *ary,int len)
{
    QSort(ary,0,len-1);
}
int _tmain(int argc, _TCHAR* argv[])
{
    printf("before sort:
");
    prt_ary(src_ary,10);
    
    quickSort(src_ary,10);
    
    printf("after sort:
");
    prt_ary(src_ary,10);



    getchar();
    return 0;
}

测试结果：

冒泡排序中，优化其算法的时候，只有有一次没有元素移动，就可以判断排序完成，减少了不必要的比较，提高了时间效率。

快速排序的优化可以从这些方面入手，

在getpiovtPos函数中，可以不需要交换，直接将最后的结果赋给最后的需要交换的那个元素就可以了。比如上图中，第二趟poivt元素4，经过了

多次交换位置（绿色的箭头），最后到达它应该的位置。

int getpiovtPos_opt(myDataType *ary,int low,int high)
{
    int poivtVal = ary[low];
    while(low < high)
    {
        while(low < high && ary[high] >= poivtVal)
        {
            high--;
        }
        //覆盖
        ary[low] = ary[high];

        while(low < high && ary[low] <= poivtVal)
        {
            low++;
        }
        //覆盖
        ary[high] = ary[low];
    }
    ary[low] = poivtVal;
    return low;
}

补充：

假设，每次取poivt元素都是待排元素最大的元素，那么这就是该排序最差的效率。

能不能通过改进，通过一种方法，能够避免这样的情况？

比如掷硬币，得到正面的概率永远是1/2，那么我们也能够增加一个随机数，能够使得poivt的值都是随机的，这样就能够避免人为的取得较差的效率。