重谈快速排序

重谈快速排序

         ——《数据结构与算法分析——C语言描述》

         快速排序是最为常见的排序算法之一。谷歌、百度“快速排序”，会有很多快速排序的讲解和代码实现。但是这么多实现中，真正好的实现并不多见，快速排序思想很简单，但是实现起来有很多细节需要注意，稍不留意，就会出现错误或者效率降低。

         快速排序有如下两个关键点：

         1.枢纽元的选择

         2.选定了枢纽元后，如何进行左右分割

         这两点都会直接影响快速排序的效率，尤其是第二点，如果有些细节实现没有考虑清楚，会导致效率降低，甚至出现死循环。

         选定了枢纽元后，进行左右分割有很多方法，只要最后分割的左右两部分元素满足小于或大于枢纽元即可。

         常见的方法有挖坑填数法，具体实现网上有很多。但是大多数实现虽然完成了快速排序的功能，其运行效率并不是最好的，尤其是当待排序序列中的元素都是一样时，大多数的实现其时间复杂度退化为O(N*N)。而理想情况下，即便待排序序列中元素都一样时，快排的时间复杂度也应该为O(NlogN)。网上一些实现例子有：实现1、2、3、4。

         对待排序序列进行分割思想很简单，实现起来有很多细节需要把握，稍不留意就会造成偏差，其原因在于我们选定枢纽元后，对待排序的分割操作是在原序列的上进行的，其空间复杂度为O(1)，这样会造成分割过程中一些细节的处理需要稍微谨慎。如果开辟一个临时的序列空间，用于暂存分割的序列，那么其空间复杂度为O(N)，时间复杂度没有提高，但是整个逻辑流程会变得很清晰，不会导致什么错误。

         本文，我们是依照经典数据结构教材《数据结构与算法分析——C语言描述》中关于快速排序的讲解，对排序排序进行一实现。相关原理细节可以参阅本书。我们给出快速排序的实现，代码中添加一些快速排序的注释说明。

         快速排序的最坏情况、最好情况、平均情况时间复杂度分析可以参照一些教材。我们这里重点在于算法的实现，不涉及数学方面的理论证明。

// 快速排序的实现

#include <iostream>

using namespace std;



// 交换函数

void swap(int& a, int& b)

{

    int t = a;

    a = b;

    b = t;

}



// 该函数用于选择合适的枢纽元

// 具体做法是：选取三个元素，这三个元素为待排序序列中的第一个、最后一个、中间一个

// 去三个元素的中位数，作为快排的枢纽元

// 三个元素的选取也可以完全随机，但是没必要完全随机

// 该函数有两个功能：1.选择合适的枢纽元；2.将枢纽元交换到right-1位置

int Median3(int arr[], int left, int right)

{

    // 取中间的坐标

    int center = (left + right) / 2;



    // 对三个数进行排序

    if (arr[left] > arr[center])

    {

        swap(arr[left], arr[center]);

    }

    if (arr[left] > arr[right])

    {

        swap(arr[left], arr[right]);

    }

    if (arr[center] > arr[right])

    {

        swap(arr[center], arr[right]);

    }



    // 我们选arr[center]作为枢纽元

    // arr[right]本身会大于等于枢纽元

    // arr[left]本身会小于等于枢纽元

    // 所以，我们不再将枢纽元置坐标置为right，而是置为right-1

    // 在后续操作中，i的初始值设置为left+1，j的初始值设置为right-2



    // 将枢纽元置于序列的后面，但不是最后一个——right，而是right-1

    swap(arr[center], arr[right - 1]);



    // 返回枢纽元

    return arr[right - 1];

}



// 打印序列

void PrintArr(int arr[], int n)

{

    for (int i = 0; i < n; ++i)

    {

        cout << arr[i] << ' ';

    }

    cout << endl;

}



// 插入排序

// 时间复杂度O(N*N)

void InsertionSort(int arr[], int n)

{

    if (n <= 1)

    {

        return;

    }

    for (int i = 1; i < n; ++i)

    {

        int tmp = arr[i];

        int p   = i - 1;

        while (p >= 0 && arr[p] > arr[p + 1])

        {

            arr[p + 1] = arr[p];

            --p;

        }

        arr[p + 1] = tmp;

    }

}



// 用于定义调用快速排序的最低元素个数：Cutoff+1

const int Cutoff = 3;



// 快速排序实现

// 相关细节详见函数内注释说明

void QSort(int arr[], int left, int right)

{

    int i = 0, j = 0;

    int pivot = 0;



    if (left + Cutoff <= right) // 如果元素个数大于等于Cutoff+1个，则调用快速排序

    //if (left < right) // 如果没有插入排序的话

    {

        pivot = Median3(arr, left, right);

        // Median3函数已经选择出枢纽元

        // 并且将枢纽元交换到right-1的位置



        i = left; // 注意这里还不是left+1，因为后面i的操作是++i

        j = right - 1; // 这里j还不是right-2，因为后面j的操作是--j



        for (;;)

        {

            while (arr[++i] < pivot);

            // 说明：++i操作，从left+1位置开始

            // 如果i元素小于枢纽元，则i右移

            // 不能使<=,因为如果真个序列的元素都是一个值，那么会造成时间复杂度为O(N*N)

            // <可以使时间复杂度为O(NlogN)，另一原因是++i

            // <导致=也会停止，进行交换



            while (arr[--j] > pivot);

            // 参照++i

            // 不能使>=，因为同样会导致时间复杂度为O(N*N)



            if (i < j)

            {

                // 如果i和j没有交叉，此时，arr[i]大于等于pivot、arr[j]小于等于pivot

                // 交换两个数

                // 如果arr[i]和arr[j]都等于pivot，也没关系，直接交换，因为上面是++i和--j



                swap(arr[i], arr[j]);

            }

            else

            {

                // 这里有可能是i=j

                // 如果出现i=j，说明arr[i]>=pivot,arr[j]<=pivot,又因为i=j，所以arr[i]=arr[j]，所以arr[i] = pivot



                // 如果i>j

                // 这里只能出现一种情况就是i=j+1

                

                // 不管是i=j还是i>j，这一轮交换完毕

                break;

            }

        }



        // for 循环结束之后进行交换

        // 此时i指向的元素大于或等于枢纽元，j指向的元素小于或等于枢纽元

        // 由于枢纽元此时在right-1位置，所以需要枢纽元和i元素交换

        swap(arr[i], arr[right - 1]);



        // 完成一轮分割后，进行下一轮分割

        // 分治递归

        // 注意下一轮分割的左右部分都不包含上一轮的枢纽元，因为枢纽元是左右部分的中间元素，没必要包含

        // 更为重要的是，如果包含了，有可能导致死循环，递归无法结束

        // 此时枢纽元所在的位置为i

        QSort(arr, left, i - 1);

        QSort(arr, i + 1, right);

    }

    else // 调用插入排序

    {

        InsertionSort(arr + left, right - left + 1);



        // 插入排序和快速排序的时间复杂度不同，各自有各自的特点和适用场合

    }

}



// 对快速排序进行封装

void QuickSort(int arr[], int n)

{

    QSort(arr, 0, n - 1);

}



int main()

{

    int arr[] = {8, 1, 4, 9, 6, 3, 5, 2, 7, 0};



    PrintArr(arr, sizeof (arr) / sizeof (*arr));

    QuickSort(arr, sizeof (arr) / sizeof (*arr));

    PrintArr(arr, sizeof (arr) / sizeof (*arr));



    return 0;

}

         对于QSort中循环的实现：

        i = left; // 注意这里还不是left+1，因为后面i的操作是++i

        j = right - 1; // 这里j还不是right-2，因为后面j的操作是--j



        for (;;)

        {

            while (arr[++i] < pivot);

        

            while (arr[--j] > pivot);

            

            if (i < j)

            {

                swap(arr[i], arr[j]);

            }

            else

            { 

                break;

            }

        }

         如果我们将其改为：

        i = left + 1;  // 一开始就将i置为left+1

        j = right - 2; // 一开始就将j置为right-2



        for (;;)

        {

            while (arr[i] < pivot)

            {

                ++i;

            }

            while (arr[j] > pivot)

            {

                --j;

            }

            if (i < j)

            {

                swap(arr[i], arr[j]);

            }

            else

            {

                break;

            }

        }

         如果出现arr[i]=arr[j]=pivot情况，for循环将进入死循环，因为每次检查到arr[i]=pivot和arr[j]=pivot就会终止循环，并且i<j，相互交换，还都是pivot，无法终止。

         一个改进的方法就是，我们在每次swap之后，修改i和j的值，对i自加，对j自减，这种操作是可行的，因为当前i和j元素交换，满足i元素小于等于pivot，j元素大于等于pivot。改进如下：

        i = left + 1;  // 一开始就将i置为left+1

        j = right - 2; // 一开始就将j置为right-2



        for (;;)

        {

            while (arr[i] < pivot)

            {

                ++i;

            }

            while (arr[j] > pivot)

            {

                --j;

            }

            if (i < j)

            {

                swap(arr[i], arr[j]);

                ++i; // 修改i

                --j; // 修改j

            }

            else

            {

                break;

            }

        }

         完整的程序如下：

// 两个循环

#include <iostream>

using namespace std;



// 交换函数

void swap(int& a, int& b)

{

    int t = a;

    a = b;

    b = t;

}



// 该函数用于选择合适的枢纽元

// 具体做法是：选取三个元素，这三个元素为待排序序列中的第一个、最后一个、中间一个

// 去三个元素的中位数，作为快排的枢纽元

// 三个元素的选取也可以完全随机，但是没必要完全随机

// 该函数有两个功能：1.选择合适的枢纽元；2.将枢纽元交换到right-1位置

int Median3(int arr[], int left, int right)

{

    // 取中间的坐标

    int center = (left + right) / 2;



    // 对三个数进行排序

    if (arr[left] > arr[center])

    {

        swap(arr[left], arr[center]);

    }

    if (arr[left] > arr[right])

    {

        swap(arr[left], arr[right]);

    }

    if (arr[center] > arr[right])

    {

        swap(arr[center], arr[right]);

    }



    // 我们选arr[center]作为枢纽元

    // arr[right]本身会大于等于枢纽元

    // arr[left]本身会小于等于枢纽元

    // 所以，我们不再将枢纽元置坐标置为right，而是置为right-1

    // 在后续操作中，i的初始值设置为left+1，j的初始值设置为right-2



    // 将枢纽元置于序列的后面，但不是最后一个——right，而是right-1

    swap(arr[center], arr[right - 1]);



    // 返回枢纽元

    return arr[right - 1];

}



// 打印序列

void PrintArr(int arr[], int n)

{

    for (int i = 0; i < n; ++i)

    {

        cout << arr[i] << ' ';

    }

    cout << endl;

}



// 插入排序

// 时间复杂度O(N*N)

void InsertionSort(int arr[], int n)

{

    if (n <= 1)

    {

        return;

    }

    for (int i = 1; i < n; ++i)

    {

        int tmp = arr[i];

        int p   = i - 1;

        while (p >= 0 && arr[p] > arr[p + 1])

        {

            arr[p + 1] = arr[p];

            --p;

        }

        arr[p + 1] = tmp;

    }

}



// 用于定义调用快速排序的最低元素个数：Cutoff+1

const int Cutoff = 3;



// 快速排序实现

// 相关细节详见函数内注释说明

void QSort(int arr[], int left, int right)

{

    int i = 0, j = 0;

    int pivot = 0;



    if (left + Cutoff <= right) // 如果元素个数大于等于Cutoff+1个，则调用快速排序

    //if (left < right) // 如果没有插入排序的话

    {

        pivot = Median3(arr, left, right);

        // Median3函数已经选择出枢纽元

        // 并且将枢纽元交换到right-1的位置



        i = left; // 注意这里还不是left+1，因为后面i的操作是++i

        j = right - 1; // 这里j还不是right-2，因为后面j的操作是--j



        for (;;)

        {

            while (arr[++i] < pivot);

            // 说明：++i操作，从left+1位置开始

            // 如果i元素小于枢纽元，则i右移

            // 不能使<=,因为如果真个序列的元素都是一个值，那么会造成时间复杂度为O(N*N)

            // <可以使时间复杂度为O(NlogN)，另一原因是++i

            // <导致=也会停止，进行交换



            while (arr[--j] > pivot);

            // 参照++i

            // 不能使>=，因为同样会导致时间复杂度为O(N*N)



            if (i < j)

            {

                // 如果i和j没有交叉，此时，arr[i]大于等于pivot、arr[j]小于等于pivot

                // 交换两个数

                // 如果arr[i]和arr[j]都等于pivot，也没关系，直接交换，因为上面是++i和--j



                swap(arr[i], arr[j]);

            }

            else

            {

                // 这里有可能是i=j

                // 如果出现i=j，说明arr[i]>=pivot,arr[j]<=pivot,又因为i=j，所以arr[i]=arr[j]，所以arr[i] = pivot



                // 如果i>j

                // 这里只能出现一种情况就是i=j+1

                

                // 不管是i=j还是i>j，这一轮交换完毕

                break;

            }

        }



        // for 循环结束之后进行交换

        // 此时i指向的元素大于或等于枢纽元，j指向的元素小于或等于枢纽元

        // 由于枢纽元此时在right-1位置，所以需要枢纽元和i元素交换

        swap(arr[i], arr[right - 1]);



        // 完成一轮分割后，进行下一轮分割

        // 分治递归

        // 注意下一轮分割的左右部分都不包含上一轮的枢纽元，因为枢纽元是左右部分的中间元素，没必要包含

        // 更为重要的是，如果包含了，有可能导致死循环，递归无法结束

        // 此时枢纽元所在的位置为i

        QSort(arr, left, i - 1);

        QSort(arr, i + 1, right);

    }

    else // 调用插入排序

    {

        InsertionSort(arr + left, right - left + 1);



        // 插入排序和快速排序的时间复杂度不同，各自有各自的特点和适用场合

    }

}



// 对快速排序进行封装

void QuickSort(int arr[], int n)

{

    QSort(arr, 0, n - 1);

}



// 快速排序实现

// 相关细节详见函数内注释说明

void QSort2(int arr[], int left, int right)

{

    int i = 0, j = 0;

    int pivot = 0;



    if (left + Cutoff <= right)

    {

        pivot = Median3(arr, left, right);





        i = left + 1;  // 一开始就将i置为left+1

        j = right - 2; // 一开始就将j置为right-2



        for (;;)

        {

            while (arr[i] < pivot)

            {

                ++i;

            }

            while (arr[j] > pivot)

            {

                --j;

            }

            if (i < j)

            {

                swap(arr[i], arr[j]);

                ++i; // 修改i

                --j; // 修改j

            }

            else

            {

                break;

            }

        }



        swap(arr[i], arr[right - 1]);



        QSort(arr, left, i - 1);

        QSort(arr, i + 1, right);

    }

    else

    {

        InsertionSort(arr + left, right - left + 1);

    }

}



// 对QSort2封装

void QuickSort2(int arr[], int n)

{

    QSort2(arr, 0, n - 1);

}



int main()

{

    int arr[] = {8, 1, 4, 9, 6, 3, 5, 2, 7, 0};



    PrintArr(arr, sizeof (arr) / sizeof (*arr));

    QuickSort2(arr, sizeof (arr) / sizeof (*arr));

    PrintArr(arr, sizeof (arr) / sizeof (*arr));



    int arr2[] = {9, 9, 9, 9, 9, 9, 9, 9, 9, 9};



    PrintArr(arr2, sizeof (arr2) / sizeof (*arr2));

    QuickSort2(arr2, sizeof (arr2) / sizeof (*arr2));

    PrintArr(arr2, sizeof (arr2) / sizeof (*arr2));



    return 0;

}

 

       插入排序和快速排序

         插入排序的时间复杂度是O(N*N)，快速排序平均的时间复杂度是O(NlogN)。但是并不是所有情况下快速排序都优于插入排序。当待排序元素个数较少时，更适宜用插入排序，比如程序中如果left+Cutoff>right时。

 

       总结

         以上是关于快速排序的相关内容。现在网上大多数快速排序的实现都并不是太好，存在或多或少的瑕疵，比如在分割过程中，如果当全部元素都是一样时，时间复杂度将为O(N*N)等。

         快速排序的分割操作是在其自身位置进行的分割，容易导致分割过程中一些细节性问题。但是分割的思想很简单，目的是为了最大化的平分左右部分。