快速排序一步一步优化

最新推荐文章于 2022-11-08 11:23:34 发布

weixin_30952535

最新推荐文章于 2022-11-08 11:23:34 发布

阅读量73

点赞数

文章标签：数据结构与算法

原文链接：http://www.cnblogs.com/vipchenwei/p/7460293.html

版权

一、快速排序介绍

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

　　算法思想：1.先从数组中取出一个数组作为枢轴，一般情况下选取数组的第一个或者最后一个元素作为枢轴，当然可以选取其他的，在后面的优化措施里面，我会慢慢介绍。

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

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

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

二、内容

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

　　我们选取第一个数作为枢轴。

　　下面，我们来看看第一趟遍历过程：

　　我们从左循环了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;
}

三、优化　

　　我们都知道，快速排序的效率高低主要在于枢轴的选取，无论选取首个元素还是最后一个元素作为枢轴，我们都要对数组进一次遍历。因此，要想优化快排，还得从枢轴的选取下手。

　　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个），则不能进行三数取中值，此时直接使用简单的排序（例如冒泡）即可，而且从效率的角度来考虑这也是合理的，因为可以避免函数调用的开销。
    }

四、进一步优化

　　上述三种快排，在处理重复数的时候，效率并没有很大提高，因此，我们可以想办法优化。

　　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;  
    }  
}