快速排序一步一步优化

时间 2019-11-08

标签快速排序一步优化繁體版

原文原文链接

1、快速排序介绍

　　快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，一般称其为分治法(Divide-and-ConquerMethod)。html

　　算法思想：1.先从数组中取出一个数组做为枢轴，通常状况下选取数组的第一个或者最后一个元素做为枢轴，固然能够选取其余的，在后面的优化措施里面，我会慢慢介绍。java

　　　　　　　2.双向遍历，从左边选取一个比枢轴大的数，从右边选择一个比枢轴小的数，而后交换这两个数；算法

　　　　　　　3.重复步骤2，直到在枢轴的左边都比枢轴小，枢轴右边的数都比枢轴大。数组

　　算法的时间复杂度：O(nlogn)安全

2、内容

　　示例数组：arr = {1,4,2,5,6,7,9,3};dom

　　咱们选取第一个数做为枢轴。ide

　　下面，咱们来看看第一趟遍历过程：函数

　　咱们从左循环了3次找到了比枢大的数5，从右循环找到了比枢轴小的数3，接下来，咱们要交换这两个数：性能

　　至此，第一趟遍历结束，可是这并无达到要求。咱们来看看第二趟遍历的结果：优化

　　交换：

　　因为，上述已经知足了条件，所以没必要进行再次交换。

　　　　直到最后一趟，咱们枢轴归位：

　　代码实现：

int qsort(int *a,int left,int right){
    if (right <= left)
        return -1;
    int pivot = a[right];
    int i = left;
    int j = right - 1;

    //从前向后扫描，不须要判断是否会出现越界问题
    while(true){
        while(a[i++] < pivot);

        //从后向前扫描，要防止越界
        while(a[j] > pivot && j >= left){
            j--;
        }
        if (i < j)
            swap(a[i++],a[j--]);
        else{
            break;
        }
    }
    swap(a[i],pivot); // 最后一趟是将a[i]与pivot交换
    qsort(a,left,i -1);
    qsort(a,i+1,right);
    return 0;
}

3、优化　

　　咱们都知道，快速排序的效率高低主要在于枢轴的选取，不管选取首个元素仍是最后一个元素做为枢轴，咱们都要对数组进一次遍历。所以，要想优化快排，还得从枢轴的选取下手。

　　1.随机选取法

　　引入缘由：在待排序列是部分有序时，固定选取枢轴使快排效率底下，要缓解这种状况，就引入了随机选取枢轴

　　思路：使用随机数生成函数生成一个随机数rand，随机数的范围为[left, right]，并用此随机数为下标对应的元素a[rand]做为中轴，并与最后一个元素a[right]交换，而后进行

与选取最后一个元素做为中轴的快排同样的算法便可。

　　优势：这是一种相对安全的策略。因为枢轴的位置是随机的，那么产生的分割也不会老是会出现劣质的分割。在整个数组数字全相等时，仍然是最坏状况，时间复杂度是O(n^2）。实际上，随机化快速排序获得理论最坏状况的可能性仅为1/(2^n）。因此随机化快速排序能够对于绝大多数输入数据达到O(nlogn）的指望时间复杂度。

　　代码实现：

int random(int left,int right){
    return rand() % (right - left + 1) + left;
}

void Qsort(int *a,int left,int right){
    if (left >= right)
    {
        return;
    }
    //随机选取一个元素做为枢轴，并与最后一个元素进行交换
    int ic = random(left,right);
    swap(a[ic],a[right]);

    int midIndex = data[right];
    int i = left;
    int j = right - 1;

    while(true){
        //找大于枢轴的数据
        while(a[i++] < midIndex);

        //找到小于枢轴的数据
        while(a[j] > midIndex && j >= left){
            j--;
        }
        //数据已经找到，准备交换
        if (i < j)
        {
            swap(a[i++],a[j--]);
        }
        else{
            break;
        }
    }
    swap(a[i],midIndex); //将枢轴放在正确的位置
    Qsort(a,left,i -1);
    Qsort(a,i+1,right);
}

　　2.三数取中（median-of-three）

　　引入的缘由：虽然随机选取枢轴时，减小出现很差分割的概率，可是仍是最坏状况下仍是O(n^2），要缓解这种状况，就引入了三数取中选取枢轴

　　思路：假设数组被排序的范围为left和right，center=（left+right）/2，对a[left]、a[right]和a[center]进行适当排序，取中值为中轴，将最小者放a[left]，最大者放在a[right]，把中轴元与a[right-1]交换，并在分割阶段将i和j初始化为left+1和right-2。而后使用双向描述法，进行快排。

　　分割好处：　　　　　　

　　　　1.将三元素中最小者被分到a[left]、最大者分到a[right]是正确的，由于当快排一趟后，比中轴小的放到左边，而比中轴大的放到右边，这样就在分割的时候把它们分到了正确的位置，减小了一次比较和交换。

　　　　2.在前面所说的全部算法中，都有双向扫描时的越界问题，而使用这个分割策略则能够解决这个问题。由于i向右扫描时，必然会遇到不小于中轴的数a[right-1]，而j在向左扫描时，必然会遇到不大于中轴的数a[left]，这样，a[right-1]和a[left]提供了一个警惕标记，因此不须要检查下标越界的问题。

　　分析：最佳的划分是将待排序的序列分红等长的子序列，最佳的状态咱们可使用序列的中间的值，也就是第N/2个数。但是，这很难算出来，而且会明显减慢快速排序的速度。这样的中值的估计能够经过随机选取三个元素并用它们的中值做为枢纽元而获得。事实上，随机性并无多大的帮助，所以通常的作法是使用左端、右端和中心位置上的三个元素的中值做为枢纽元。显然使用三数中值分割法消除了预排序输入的很差情形，而且减小快排大约14%的比较次数

　　例子：

　　　　初始数组：6 1 8 9 4 3 5 2 7 0

　　　　选取三个中间数：6 1 8 9 4 3 5 2 7 0

　　　　对这三个数进行排序：0 1 8 9 4 3 5 2 7 6

　　　　最后中轴与a[right-1]交换：0 1 8 9 7 3 5 2 4 6

　　实例代码：

int Median(int *a,int left,int right){
    int midIndex = (left + right)>>1;
    if (a[left] > a[midIndex])
    {
        swap(a[left],a[midIndex]);
    }
    if (a[left] > a[right])
    {
        swap(a[left],a[right]);
    }
    if (a[midIndex] > a[right])
    {
        swap(a[midIndex],a[right]);
    }
    swap(a[midIndex],a[right-1]);
    return a[right-1]; //返回中轴
}

void qSort(int *a,int left,int right){
        //若是须要排序的数据大于3个则使用快速排序
        if (right - left >=3)
        {
            int midIndex = Median(a,left,right);
            int begin = left;
            int end = right - 1;
            while (true){
                while(a[++begin] < midIndex);
                while(a[--end]<midIndex);
                if (begin < end)
                {
                    swap(a[begin],a[end]);
                }
                else{
                    swap(a[begin],a[right -1]);//将枢轴移动到什么时候位置
                    break;
                }
            }
            qSort(a,left,begin -1);
            qSort(a,begin + 1,right);
        }
        else{
            BubbleSort(a,left,right);//当数据小于3个,直接用冒泡排序
        }//当要排序的数据不多时（小于3个），则不能进行三数取中值，此时直接使用简单的排序（例如冒泡）便可，并且从效率的角度来考虑这也是合理的，由于能够避免函数调用的开销。
    }

4、进一步优化

　　上述三种快排，在处理重复数的时候，效率并无很大提升，所以，咱们能够想办法优化。

　　1.当待排序序列长度分割到必定大小后，使用插入排序。

　　　缘由：对于很小和部分有序的数组，快排不如插排好。当待排序序列的长度分割到必定大小后，继续分割的效率比插入排序要差，此时可使用插排而不是快排

if (high - low + 1 < 10)  
{  
    InsertSort(arr,low,high);  
    return;  
}//else时，正常执行快排

　　2.在一次分割结束后，能够把与Key相等的元素聚在一块儿，继续下次分割时，不用再对与key相等元素分割（处理重复效率极高）　

　　举例：

　　　　待排序序列 1 4 6 7 6 6 7 6 8 6

　　　　三数取中选取枢轴：下标为4的数6

　　　　转换后，待分割序列：6 4 6 7 1 6 7 6 8 6 枢轴key：6

　　　　本次划分后，未对与key元素相等处理的结果：1 4 6 6 7 6 7 6 8 6

　　　　下次的两个子序列为：1 4 6 和 7 6 7 6 8 6

　　　　本次划分后，对与key元素相等处理的结果：1 4 6 6 6 6 6 7 8 7

　　　　下次的两个子序列为：1 4 和 7 8 7

　　　　通过对比，咱们能够看出，在一次划分后，把与key相等的元素聚在一块儿，能减小迭代次数，效率会提升很多

　　具体过程：在处理过程当中，会有两个步骤

　　　　第一步，在划分过程当中，把与key相等元素放入数组的两端

　　　　第二步，划分结束后，把与key相等的元素移到枢轴周围

　　举例：

　　　　待排序序列 1 4 6 7 6 6 7 6 8 6

　　　　三数取中选取枢轴：下标为4的数6

　　　　转换后，待分割序列：6 4 6 7 1 6 7 6 8 6 枢轴key：6

　　　　第一步，在划分过程当中，把与key相等元素放入数组的两端

　　　　结果为：6 4 1 6(枢轴) 7 8 7 6 6 6

　　　　此时，与6相等的元素全放入在两端了

　　　　第二步，划分结束后，把与key相等的元素移到枢轴周围

　　　　结果为：1 4 66(枢轴) 6 6 6 7 8 7

　　　　此时，与6相等的元素全移到枢轴周围了

　　　　以后，在1 4 和 7 8 7两个子序列进行快排

　　代码示例：

void QSort(int arr[],int low,int high)  //三数中值+汇集相等元素
{
    int first = low;
    int last = high;

    int left = low;
    int right = high;

    int leftLen = 0;
    int rightLen = 0;

    if (high - low + 1 < 10)
    {
        InsertSort(arr,low,high);
        return;
    }
    
    //一次分割
    int key = SelectPivotMedianOfThree(arr,low,high);//使用三数取中法选择枢轴
        
    while(low < high)
    {
        while(high > low && arr[high] >= key)
        {
            if (arr[high] == key)//处理相等元素
            {
                swap(arr[right],arr[high]);
                right--;
                rightLen++;
            }
            high--;
        }
        arr[low] = arr[high];
        while(high > low && arr[low] <= key)
        {
            if (arr[low] == key)
            {
                swap(arr[left],arr[low]);
                left++;
                leftLen++;
            }
            low++;
        }
        arr[high] = arr[low];
    }
    arr[low] = key;

    //一次快排结束
    //把与枢轴key相同的元素移到枢轴最终位置周围
    int i = low - 1;
    int j = first;
    while(j < left && arr[i] != key)
    {
        swap(arr[i],arr[j]);
        i--;
        j++;
    }
    i = low + 1;
    j = last;
    while(j > right && arr[i] != key)
    {
        swap(arr[i],arr[j]);
        i++;
        j--;
    }
    QSort(arr,first,low - 1 - leftLen);
    QSort(arr,low + 1 + rightLen,last);
}

　　缘由：在数组中，若是有相等的元素，那么就能够减小很多冗余的划分。这点在重复数组中体现特别明显啊。

　　3.优化递归操做　

　　快排函数在函数尾部有两次递归操做，咱们能够对其使用尾递归优化

　　优势：若是待排序的序列划分极端不平衡，递归的深度将趋近于n，而栈的大小是颇有限的，每次递归调用都会耗费必定的栈空间，函数的参数越多，每次递归耗费的空间也越多。优化后，能够缩减堆栈深度，由原来的O(n)缩减为O(logn)，将会提升性能。

void QSort(int arr[],int low,int high)  
{   
    int pivotPos = -1;  
    if (high - low + 1 < 10)  
    {  
        InsertSort(arr,low,high);  
        return;  
    }  
    while(low < high)  
    {  
        pivotPos = Partition(arr,low,high);  
        QSort(arr,low,pivot-1);  
        low = pivot + 1;  
    }  
}

参考文献

　　http://blog.sina.com.cn/s/blog_5a3744350100jnec.html

　　http://www.blogjava.net/killme2008/archive/2010/09/08/331404.html

　　http://www.cnblogs.com/cj723/archive/2011/04/27/2029993.html

　　http://blog.csdn.net/zuiaituantuan/article/details/5978009

　　http://blog.csdn.net/ljianhui/article/details/16797431