【编程珠玑】读书笔记 第十一章 排序

2013-07-15 20:18:41

本章以排序为例，展示了编程过程中的一般步骤。

主要针对插入排序、快速排序进行了讨论。

之前看过一本书《剑指offer》，感觉写的很好，有具体的实例，对每个题都给出思路以及实例，并对编程中的要点进行说明，代码风格也很好，现在看这本《编程珠玑》，是因为想多了解一些编程以及算法方面的理论。

书快看完了，个人感觉这本书内容还不错，但是表达方式比较晦涩，不太好理解，比如说代码的思路说明不够清楚、编程的风格也比较糟糕，有些术语也不太好理解，比如脚手架（书中的意思是测试框架）、程序验证（书中的意思是证明编程思路的正确性）、算法调优、代码调优等。

本章的内容有些表叔还是很晦涩，排序本来是很简单的，而本章中提到的思路有的却是不好理解（有的效率还比较低），看了很长时间，才看懂。

下面给出根据书中的思路写出的完整代码，以及测试“脚手架”，“脚手架”在此处的测试却是挺好用。后面附上了测试结果，给出了待排序数组为1000,000时每种排序的时间消耗。

从测试结果可以看到，同样的排序，最快的是采用函数QuickSortAdvaced（使用随机枢轴）与QuickSortImproved_2，标准库函数qsort与QuickSortImproved_1差不多，QuickSortBasic也比较快，且比QuickSortImproved_1差不多快一倍；

而插入排序很慢，最快的插入排序大概是最快的快速排序QuickSortAdvaced的200倍；

最慢的插入排序是最快的插入排序的100倍，可见即使是同样的算法，代码的编写对程序的效率也是很重要的，要从代码上进行优化.

QuickSortBasic在划分时，使用的单向划分，在数组元素都相同的极端情况下，需要n-1次划分，而不是log2(n)次，因此时间复杂度恶化为O(n^2)；

为了改善这种情况，提出了双向划分，即为下面代码中的QuickSortImproved_1，该算法在数组元素都相同的极端情况下，可将规模减半，因此时间复杂度为O(nlog2(n))，为快速排序的最好性能；

QuickSortImproved_1的双向换分是书中给出的代码，可能是先入为主的原因，之前看到有QuickSortImproved_2中代码的写法，个人感觉QuickSortImproved_1中的写法不是很好理解，且交换次数增加很多，因此有了QuickSortImproved_2，且从运行时间上看，QuickSortImproved_2比QuickSortImproved_1要快1倍还多，若增加输入规模，速度的差别会显著；

对于QuickSortImproved_2，要注意到，Partion函数主循环while (i < j)内的循环的条件是 while (unsortedArray[j] > unsortedArray[i] && i < j)，而非 while (unsortedArray[j] >= unsortedArray[i] && i < j)，另外一个循环是while (unsortedArray[j] < unsortedArray[i] && i < j)，而非 while (unsortedArray[j] <= unsortedArray[i] && i < j)，也就是两个循环都是不包含=的，这样才能保证Partion在数组元素都相同的极端情况下，将规模减半；否则，就会使最坏的情况。

假设输入数组为已经排好序的数组，那么使用上述的算法（QuickSortBasic、QuickSortImproved_1、QuickSortImproved_2），时间性能也是最差的O(n^2)，至此，我们已经做了两种极端情况的分析，一种是数组元素都相同，我们通过双向划分解决，但该方法不能解决数组已经排好序的情况，还有没有其他的极端情况？快速排序的复杂度到底决定于哪些因素？怎样才能达到最佳性能？

在《算法导论》的7.2节指出，快速排序的运行时间与划分是否对称有关，而后者又与选择了哪一个元素来进行划分有关。如果划分是对称的，那么本算法从渐进意义上来讲，就与合并算法一样快；如果划分是不对称的，那么本算法渐进上就和插入算法一样慢。

那么，要想得到对称的划分，使用了随机划分的方法，可以得到近似对称的划分，如QuickSortAdvaced所示。QuickSortAdvaced用函数PartionRandomPivot随机选择枢轴元素，从而得到近似对称的划分。

测试环境：win7 32bit + VS2010

代码：

#include <iostream>
#include <cassert>
#include <time.h>
using namespace std;

typedef int DataType;
const int MaxSize = 100000000;
const int SortCutOff = 50;

//输入合法性检查
void CheckInvalid(int array[],int len)
{
    assert(NULL != array && len > 0);
}

//直接插入排序基本版本
void InsertSortBasic(int unsortedArray[],int len)
{
    int i;
    int j;

    CheckInvalid(unsortedArray,len);

    for (i = 1;i < len;++i)
    {
        for (j = i;j >= 0 && unsortedArray[j] < unsortedArray[j - 1];--j)
        {
            swap(unsortedArray[j],unsortedArray[j - 1]);
        }
    }
}

//直接插入排序改进，将for循环中的swap函数改为内联的，提高效率
void InsertSortImproved(int unsortedArray[],int len)
{
    int i;
    int j;
    int tmp;

    CheckInvalid(unsortedArray,len);

    for (i = 1;i < len;++i)
    {
        for (j = i;j >= 0 && unsortedArray[j] < unsortedArray[j - 1];--j)
        {
            tmp = unsortedArray[j];
            unsortedArray[j] = unsortedArray[j - 1];
            unsortedArray[j - 1] = tmp;
        }
    }
}


//直接插入排序的进一步改进
void InsertSortAdvacaed(int unsortedArray[],int len)
{
    int i;
    int j;
    int t;

    CheckInvalid(unsortedArray,len);

    for (i = 1;i < len;++i)
    {
        t = unsortedArray[i];
        for (j = i - 1;j >= 0 && unsortedArray[j] > t;--j)
        {
            unsortedArray[j + 1] = unsortedArray[j];
        }
        unsortedArray[j + 1] = t;
    }
}

//快速排序的基本版本，从一个方向进行划分
void QuickSortBasic(int unsortedArray[],int begin,int end)
{
    if (begin >= end)
    {
        return;
    }

    int i;
    int mid = begin;
    int tmp;

    for (i = begin + 1;i <= end;++i) //注意终止条件不是i < end
    {
        if (unsortedArray[i] < unsortedArray[begin])
        {
            ++mid;
            tmp = unsortedArray[i];
            unsortedArray[i] = unsortedArray[mid];
            unsortedArray[mid] = tmp;
        }
    }

    swap(unsortedArray[begin],unsortedArray[mid]);
    QuickSortBasic(unsortedArray,begin,mid - 1);
    QuickSortBasic(unsortedArray,mid + 1,end);
}

//快速排序的改进，从两个方向划分
void QuickSortImproved_1(int unsortedArray[],int begin,int end)
{
    if (begin >= end)
    {
        return;
    }

    int i, j;
    DataType t;
    t = unsortedArray[begin];
    i = begin;
    j = end + 1;

    for (;;) 
    {
        do i++; 
        while (i <= end && unsortedArray[i] < t);
        do j--; 
        while (unsortedArray[j] > t);
        if (i > j)
            break;
        swap(unsortedArray[i],unsortedArray[j]);
    }
    swap(unsortedArray[begin],unsortedArray[j]);
    QuickSortImproved_1(unsortedArray,begin,j - 1);
    QuickSortImproved_1(unsortedArray,j + 1,end);
}

//将a_unsorted的首个元素放到排序后的位置，返回该数据的位置
int Partion(int unsortedArray[],int begin,int end)
{
    int i = begin;
    int j = end;
    int tmp;

    while (i < j)
    {
        while (unsortedArray[j] > unsortedArray[i] && i < j)  //从后向前比较，知道发现元素不大于轴a_unsorted[i]
        {
            --j;    
        }

        if (i < j)
        {
            tmp =  unsortedArray[i];    //交换之后，轴变为a_unsorted[j]
            unsortedArray[i] = unsortedArray[j];
            unsortedArray[j] = tmp;
            ++i;        //缩小范围
        }

        while (unsortedArray[i] < unsortedArray[j] && i < j)//从前向后比较，知道发现元素不小于轴a_unsorted[j]
        {
            ++i;    
        }

        if (i < j)
        {
            tmp = unsortedArray[i];        //交换之后，轴变为a_unsorted[i]
            unsortedArray[i] = unsortedArray[j];
            unsortedArray[j] = tmp;

            --j;     //缩小范围
        }
    }

    return i;
}

//快速排序，更好的写法
void QuickSortImproved_2(int unsortedArray[],int begin,int end)
{
    if (begin >= end)
    {
        return;
    }

    int mid = Partion(unsortedArray,begin,end);

    QuickSortImproved_2(unsortedArray,begin,mid - 1);
    QuickSortImproved_2(unsortedArray,mid + 1,end);
}

//产生在[lowBound,upperBound - 1]区间的随机数
int RandomIntGenerate(int lowBound, int upperBound)
{    
    return (lowBound + (RAND_MAX * rand() + rand()) % (upperBound - lowBound + 1) );
}

//将a_unsorted的首个元素放到排序后的位置，返回该数据的位置
int PartionRandomPivot(int unsortedArray[],int begin,int end)
{
    int i = begin;
    int j = end;
    int tmp;

    int pivotIndex =  RandomIntGenerate(begin,end);
    swap(unsortedArray[begin],unsortedArray[pivotIndex]);

    while (i < j)
    {
        while (unsortedArray[j] > unsortedArray[i] && i < j)  //从后向前比较，知道发现元素不大于轴a_unsorted[i]
        {
            --j;    
        }

        if (i < j)
        {
            tmp =  unsortedArray[i];    //交换之后，轴变为a_unsorted[j]
            unsortedArray[i] = unsortedArray[j];
            unsortedArray[j] = tmp;
            ++i;        //缩小范围
        }

        while (unsortedArray[i] < unsortedArray[j] && i < j)//从前向后比较，知道发现元素不小于轴a_unsorted[j]
        {
            ++i;    
        }

        if (i < j)
        {
            tmp = unsortedArray[i];        //交换之后，轴变为a_unsorted[i]
            unsortedArray[i] = unsortedArray[j];
            unsortedArray[j] = tmp;

            --j;     //缩小范围
        }
    }

    return i;
}

//快速排序的进一步改进，
//随机选择枢轴元素
//且在数组长度小于一定值（此处为SortCutOff）时，用插入排序
void QuickSortAdvaced(int unsortedArray[],int begin,int end)
{
    if (begin >= end)
    {
        return;
    }

    if((end - begin + 1) < SortCutOff)
    {
        InsertSortAdvacaed(unsortedArray,(end - begin + 1));
        return;
    }

    int mid = PartionRandomPivot(unsortedArray,begin,end);

    QuickSortImproved_2(unsortedArray,begin,mid - 1);
    QuickSortImproved_2(unsortedArray,mid + 1,end);
}

int IntCompare(const void *_p,const void *_q)
{    
    int *p = (int *) _p;
    int *q= (int *) _q;
    return (*p - *q);
}

void DisplayArray(int array[],int len)
{
    CheckInvalid(array,len);

    for (int i = 0;i < len;++i)
    {
        cout<<array[i]<<"	";
    }
    cout<<endl;
}

//测试“脚手架”
void TestDriver()
{    
    //int unsortedArray[MaxSize];
    int *unsortedArray = new int[MaxSize];
    size_t programToTest;
    size_t lengthOfUnsortedArray;
    int MinRandomInt;
    int MaxRandomInt;
    size_t i;
    int timeStart = 0;
    double timeCostAverage = 0;
    
    cout<<"the identifier of the program is :"<<endl;
    cout<<"InsertSortBasic : 11"<<endl;
    cout<<"InsertSortImproved : 12"<<endl;
    cout<<"InsertSortAdvacaed : 13"<<endl;
    cout<<"QuickSortBasic : 21"<<endl;
    cout<<"QuickSortImproved_1 : 22"<<endl;
    cout<<"QuickSortImproved_2 : 23"<<endl;
    cout<<"QuickSortAdvaced : 24"<<endl;
    cout<<endl;

    cout<<"please enter the length Of UnsortedArray,MinRandomInt and MaxRandomInt :"<<endl;
    cin>>lengthOfUnsortedArray>>MinRandomInt>>MaxRandomInt;
    cout<<"please enter the identifier of the program to test (end with ctrl+z): "<<endl;
    while (cin>>programToTest)
    {
        for (i = 0;i < lengthOfUnsortedArray;++i)  //准备待排序数组
        {
            unsortedArray[i] = RandomIntGenerate(MinRandomInt,MaxRandomInt);
        }

    /*    cout<<"the unsorted array is :"<<endl;
        DisplayArray(unsortedArray,lengthOfUnsortedArray);*/
        timeStart = clock();
        switch (programToTest)
        {
            case 11: 
                cout<<"Test InsertSortBasic..."<<endl;
                InsertSortBasic(unsortedArray,lengthOfUnsortedArray);
                break;

            case 12: 
                cout<<"Test InsertSortImproved..."<<endl;
                InsertSortImproved(unsortedArray,lengthOfUnsortedArray);
                break;

            case 13: 
                cout<<"Test InsertSortAdvacaed..."<<endl;
                InsertSortAdvacaed(unsortedArray,lengthOfUnsortedArray);
                break;
            case 21: 
                cout<<"Test QuickSortBasic..."<<endl;
                QuickSortBasic(unsortedArray,0,lengthOfUnsortedArray - 1);
                break;
            case 22: 
                cout<<"Test QuickSortImproved_1..."<<endl;
                QuickSortImproved_1(unsortedArray,0,lengthOfUnsortedArray - 1);
                break;
            case 23: 
                cout<<"Test QuickSortImproved_2..."<<endl;
                QuickSortImproved_2(unsortedArray,0,lengthOfUnsortedArray - 1);
                break;
            case 24: 
                cout<<"Test QuickSortAdvaced..."<<endl;
                QuickSortAdvaced(unsortedArray,0,lengthOfUnsortedArray - 1);
                break;
            case 25: 
                cout<<"Test qsort..."<<endl;
                qsort(unsortedArray,lengthOfUnsortedArray,sizeof(DataType),IntCompare);
                break;
            default:
                break;
        }

        timeCostAverage = 1e9 * ( clock() - timeStart ) / ( CLOCKS_PER_SEC * lengthOfUnsortedArray );
        cout<<"the average time cost per data is : "<<timeCostAverage<<" ns"<<endl;

        for (i = 0;i < lengthOfUnsortedArray - 1;++i)
        {
            if (unsortedArray[i] > unsortedArray[i + 1])
            {
                cout<<"sort bug i = "<<i<<endl;
            }
        }

        /*cout<<"the sorted array is :"<<endl;
        DisplayArray(unsortedArray,lengthOfUnsortedArray);*/

        cout<<endl;
        cout<<"please enter the identifier of the program to test (end with ctrl+z): "<<endl;
    }

    delete [] unsortedArray;
}

//使用脚手架的测试程序
int main(void)
{
    TestDriver();
    return 0;
}

//不用脚手架的测试程序
//int main(void)
//{
//    int unsortedArray[MaxSize];
//    int len = 0;
//    DataType data;
//
//    cout<<"please enter the data of the array ,end with ctrl+z : "<<endl;
//    while (cin>>data)
//    {
//        unsortedArray[len++] = data;
//    }
//    cout<<"the unsorted array is :"<<endl;
//    DisplayArray(unsortedArray,len);
//
//    /*cout<<"Test InsertSortBasic..."<<endl;
//    InsertSortBasic(unsortedArray,len);
//    cout<<"the sorted array is :"<<endl;
//    DisplayArray(unsortedArray,len);*/
//
//
//    //cout<<"Test InsertSortImproved..."<<endl;
//    //InsertSortImproved(unsortedArray,len);
//    //cout<<"the sorted array is :"<<endl;
//    //DisplayArray(unsortedArray,len);
//
//    /*cout<<"Test InsertSortAdvacaed..."<<endl;
//    InsertSortAdvacaed(unsortedArray,len);
//    cout<<"the sorted array is :"<<endl;
//    DisplayArray(unsortedArray,len);*/
//
//    /*cout<<"Test QuickSortBasic..."<<endl;
//    QuickSortBasic(unsortedArray,0,len - 1);
//    cout<<"the sorted array is :"<<endl;
//    DisplayArray(unsortedArray,len);*/
//
//    /*cout<<"Test QuickSortImproved_1..."<<endl;
//    QuickSortImproved_1(unsortedArray,0,len - 1);
//    cout<<"the sorted array is :"<<endl;
//    DisplayArray(unsortedArray,len);*/
//
//    //cout<<"Test QuickSortImproved_2..."<<endl;
//    //QuickSortImproved_2(unsortedArray,0,len - 1);
//    //cout<<"the sorted array is :"<<endl;
//    //DisplayArray(unsortedArray,len);
//
//    cout<<"Test QuickSortAdvaced..."<<endl;
//    QuickSortAdvaced(unsortedArray,0,len - 1);
//    cout<<"the sorted array is :"<<endl;
//    DisplayArray(unsortedArray,len);
//    
//    return 0;
//}

测试结果：

（可以看到，同样的排序，最快的是采用函数QuickSortAdvaced（使用随机枢轴）与QuickSortImproved_2，标准库函数qsort与QuickSortImproved_1差不多，QuickSortBasic也比较快，且比QuickSortImproved_1差不多快一倍；

而插入排序很慢，最快的插入排序大概是最快的快速排序QuickSortAdvaced的200倍；

最慢的插入排序是最快的插入排序的100倍，可见即使是同样的算法，代码的编写对程序的效率也是很重要的，要从代码上进行优化）

the identifier of the program is :
InsertSortBasic : 11
InsertSortImproved : 12
InsertSortAdvacaed : 13
QuickSortBasic : 21
QuickSortImproved_1 : 22
QuickSortImproved_2 : 23
QuickSortAdvaced : 24

please enter the length Of UnsortedArray,MinRandomInt and MaxRandomInt :
100000 -1000000 1000000
please enter the identifier of the program to test (end with ctrl+z):
24
Test QuickSortAdvaced...
the average time cost per data is : 860 ns

please enter the identifier of the program to test (end with ctrl+z):
25
Test qsort...
the average time cost per data is : 2330 ns

please enter the identifier of the program to test (end with ctrl+z):
23
Test QuickSortImproved_2...
the average time cost per data is : 860 ns

please enter the identifier of the program to test (end with ctrl+z):
22
Test QuickSortImproved_1...
the average time cost per data is : 2020 ns

please enter the identifier of the program to test (end with ctrl+z):
21
Test QuickSortBasic...
the average time cost per data is : 1080 ns

please enter the identifier of the program to test (end with ctrl+z):
13
Test InsertSortAdvacaed...
the average time cost per data is : 164740 ns

please enter the identifier of the program to test (end with ctrl+z):
12
Test InsertSortImproved...
the average time cost per data is : 297960 ns

please enter the identifier of the program to test (end with ctrl+z):
11
Test InsertSortBasic...
the average time cost per data is : 3.66578e+006 ns

please enter the identifier of the program to test (end with ctrl+z):
^Z
请按任意键继续. . .