【编程珠玑】读书笔记 第一章 开篇

2013-07-10 18:39:25

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

　　本书以一个排序的问题开篇，讨论了排序的最佳方法，并引入了位图排序的算法。实际上，此处的位图排序本质就是计数排序（关于计数排序，此处不再赘述），只不过由于此处问题的特殊性——数据没有重复，可使用更加节省空间的方法，对每一个数据，使用1bit的空间进行计数。

　　书中还给出了用标准库函数qsort、以及模板类set排序的提议，以与位图排序的性能进行比较，下面给出了几中排序方法，包括：

1. 使用模板类bitset作为计数数组实现位图排序，具体实现见代码中BitmapSort_1函数；
2. 用int型数据模拟bit型的操作实现位图排序，具体实现见下面代码中BitmapSort_2函数，该函数可在C语言下实现；
3. 用标准库函数qsort实现排序，具体实现见下面代码中main函数中qsort；
4. 用C++的模板类set或multiset实现排序；

　　上面几种方法，方法2是书中的方法，且可以用C语言实现，qsort也可用C语言实现，而其他两种方法必须用C++实现。使用前2中方法会受到用位图排序的使用场合的限制，而后面两种则没有限制。

　　下面给出上述4中方法的源代码实现，以及性能分析。

注意，性能分析部分的代码相对于前面的是有改动的，以性能分析部分的代码为最终的。

---

位图排序以及使用标准库函数qsort的排序

用位图排序的使用场合以及限制条件：

1. 待排序数组为非负数；

2. 输入数据限制在相对较小的范围内；

3. 数组元素不重复，若有重复，排序后数组会丢弃重复的元素；

上面已经提到过位图排序本质就是计数排序，而计数排序要准备一个用于计数的数组，对于位图，就是bit类型的数组。

在C++中，可以使用模板类bitset作为计数数组，具体实现见代码中BitmapSort_1函数。但在C语言中没有该类型的数据的，书中给出了一种用int型数据模拟bit型的操作，具体实现见下面代码中BitmapSort_2函数。

位图排序的实现，注意几点：

1. 在使用必须确保计数数组初初始化为全0：对于用C++中模板类bitset实现的位图排序的BitmapSort_1函数，即：Bitmap.reset();对于用int型数组模拟位图的BitmapSort_2函数，即BitmapArray[1 + N/BitsPerInt] = {0};
2. 注意语句 int BitmapArray[1 + N/BitsPerInt] = {0};   将会初始化数组所有元素，而不只是第一个；

对qsort，注意：

1. comp函数的参数类型必须为const类型，这是由qsort函数中参数cmp的类型决定的。

int comp(void *_p,void *_q)    //提示cannot convert parameter 4 from 'int (__cdecl *)(void *,void *)' to 'int (__cdecl *)(const void *,const void *)'
int comp(const void *_p,const void *_q)

用int型模拟位图的关键在与如何实现每个bit的置位、清零以及判断是否为1，书中给出了一种用位运算的方法，如下：

//用int型模拟位图，实现的位图排序
const int BitsPerInt = 32;
const int Div32Shift = 5;
const int Mod32Mask = 0x1F;

//BitmapSort_2:用位运算实现置位、清零、判断是否为1
void SetBit(int BitmapArray[],const int BitToSet)
{
    //BitmapArray[ (BitToSet >> Div32Shift) ] | = ( 1 << (BitToSet & Mod32Mask) );  //error C2059: syntax error : '='
    BitmapArray[ (BitToSet >> Div32Shift) ] = BitmapArray[ (BitToSet >> Div32Shift) ] 
    | ( 1 << (BitToSet & Mod32Mask) ); 
}

void ClearBit(int BitmapArray[],const int BitToClear)
{
    BitmapArray[ (BitToClear >> Div32Shift) ] = BitmapArray[ (BitToClear >> Div32Shift) ] 
    & ~( 1 << (BitToClear & Mod32Mask) ); 
}

//bool IsBitSet(int BitmapArray[],const int BitToSet)
bool IsBitSet(const int BitmapArray[],const int BitToCheck)  //定义为const类型，在不小心改变时，会给出报错信息
{
    return ( BitmapArray[ (BitToCheck >> Div32Shift) ] & ( 1 << (BitToCheck & Mod32Mask) ) ); 
}

位图排序完整代码：

#include <iostream>
#include <bitset>
#include <set>
using namespace std;
#define N 10

//BitmapSort_1:用C++中模板类bitset实现的位图排序
void BitmapSort_1(int ArrayUnsorted[],int n)
{
    bitset <N> Bitmap;
    int * ArraySorted = new int[n];
    int cnt = 0;
    Bitmap.reset();        //清零，保证使用之前全部为0

    int i ;
    for (i = 0;i < n;++i)     //标记各个位置
    {
        Bitmap.set(ArrayUnsorted[i]);
    }

    for (i = 0;i < n;++i)  
    {
        if ( Bitmap[i] )   //如果位置i为1，则说明i在数组ArraySorted中出现，且为排序后的第cnt个
        {
            ArrayUnsorted[cnt++] = i;
        }
    }
}

//用int型模拟位图，实现的位图排序
const int BitsPerInt = 32;
const int Div32Shift = 5;
const int Mod32Mask = 0x1F;

//BitmapSort_2:用位运算实现置位、清零、判断是否为1
void SetBit(int BitmapArray[],const int BitToSet)
{
    //BitmapArray[ (BitToSet >> Div32Shift) ] | = ( 1 << (BitToSet & Mod32Mask) );  //error C2059: syntax error : '='
    BitmapArray[ (BitToSet >> Div32Shift) ] = BitmapArray[ (BitToSet >> Div32Shift) ] 
    | ( 1 << (BitToSet & Mod32Mask) ); 
}

void ClearBit(int BitmapArray[],const int BitToClear)
{
    BitmapArray[ (BitToClear >> Div32Shift) ] = BitmapArray[ (BitToClear >> Div32Shift) ] 
    & ~( 1 << (BitToClear & Mod32Mask) ); 
}

//bool IsBitSet(int BitmapArray[],const int BitToSet)
bool IsBitSet(const int BitmapArray[],const int BitToCheck)  //定义为const类型，在不小心改变时，会给出报错信息
{
    return ( BitmapArray[ (BitToCheck >> Div32Shift) ] & ( 1 << (BitToCheck & Mod32Mask) ) ); 
}

void BitmapSort_2(int ArrayUnsorted[],const int n)
{
    int BitmapArray[1 + N/BitsPerInt] = {0};   //将会初始化数组所有元素，而不只是第一个
    int i ;
    int cnt = 0;

    for (i = 0;i < n;++i)
    {
        SetBit(BitmapArray,ArrayUnsorted[i]);
    }

    for (i = 0;i < n;++i)
    {
        if ( IsBitSet(BitmapArray,i) )
        {
            ArrayUnsorted[cnt++] = i;
            cout<<ArrayUnsorted[cnt - 1]<<endl;
        }
    }
}


//注意参数必须为const类型
//int comp(void *_p,void *_q)    //提示cannot convert parameter 4 from 'int (__cdecl *)(void *,void *)' to 'int (__cdecl *)(const void *,const void *)'
int comp(const void *_p,const void *_q)
{
    int *p = (int *)_p;
    int *q = (int *)_q;
    return (*p - *q);
}

//不需要写初始化函数，因为在定义的时候可以初始化
void Init(int BitmapArray[],const int n)
{
    for (int i = 0;i < n;++i)
    {
        BitmapArray[i] = 0;
    }
}

//显示数组元素
void DisplayArray(int ArrayUnsorted[],int n)
{
    for (int i = 0;i < n;++i)
    {
        cout<<ArrayUnsorted[i]<<"	";
    }
    cout<<endl;
}

//测试程序
int main()
{
    //int ArrayUnsorted[N] = {7,9,2,3,    4,5,1,8,    0,6};
    int ArrayUnsorted[N] = {7,9,2,2,    4,8,1,8,    0,6};

    cout<<"the unsorted array is : "<<endl;
    DisplayArray(ArrayUnsorted,N);

    //测试BitmapSort_1
    /*cout<<"Test BitmapSort_1..."<<endl;
    BitmapSort(ArrayUnsorted,N);
    cout<<"the sorted array is : "<<endl;
    DisplayArray(ArrayUnsorted,N);  */

    //测试BitmapSort_2
    cout<<"Test BitmapSort_2..."<<endl;
    BitmapSort_2(ArrayUnsorted,N);
    cout<<"the sorted array is : "<<endl;
    DisplayArray(ArrayUnsorted,N);  

    //测试系统函数qsort
    /*cout<<"Test qsort..."<<endl;
    qsort(ArrayUnsorted,N,sizeof(int),comp);
    cout<<"the sorted array is : "<<endl;
    DisplayArray(ArrayUnsorted,N);  */

    return 0;
}

---

使用C++ STL中的标准关联容器set排序

set 是一个容器，它用于储存数据并且能从一个数据集合中取出数据。它的每个元素的值必须惟一，而且系统会根据该值来自动将数据排序。每个元素的值不能直接被改变。

multiset与set的不同之处就是key可以重复，以及erase（key）的时候会删除multiset里面所有的key并且返回删除的个数。

 注意几点：

 iterator不支持运算<，因此不能用下面的方式控制循环

for (iter = SetForSort.begin();iter < SetForSort.end();++iter)

而应采用如下方式：

for (iter = SetForSort.begin();iter != SetForSort.end();++iter)

 会给出出错信息如下：

binary '<' : 'std::_Tree_const_iterator<_Mytree>' does not define this operator or a conversion to a type acceptable to the predefined operator

用下面的方式将排序结果输出到ArrayUnsorted数组，在元素有重复时，容器访问会发生越界，因为容器中元素个数小于n

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

{
  ArrayUnsorted[i] = *iter++;
 }

因为排序后的数组是在容器中存放的，所以直接采用容器的begin与end控制比较好，如下：

for (iter = SetForSort.begin();iter != SetForSort.end();++iter)
    {
        ArrayUnsorted[cnt++] = *iter;
    }

完整代码：

#include <iostream>
#include <set>
using namespace std;
#define N 10

//没有加入合法性检查以及出错处理，只是实现了函数的功能
//使用C++ STL中的标准关联容器set排序
void SetContainerSort(int ArrayUnsorted[],int n)
{
    //set <int> SetForSort;            //使用set，元素不可重复
    //set <int> :: const_iterator iter = SetForSort.begin();
    multiset <int> SetForSort;        //使用multiset，元素可重复
    multiset <int> :: const_iterator iter = SetForSort.begin();
    int i;
    int cnt = 0;

    for (i = 0;i < n;++i)
    {
        SetForSort.insert(ArrayUnsorted[i]);
    }
    
    for (iter = SetForSort.begin();iter != SetForSort.end();++iter)
    {
        ArrayUnsorted[cnt++] = *iter;
    }
}

//显示数组元素
void DisplayArray(int ArrayUnsorted[],int n)
{
    for (int i = 0;i < n;++i)
    {
        cout<<ArrayUnsorted[i]<<"	";
    }
    cout<<endl;
}

//测试程序
int main()
{
    int ArrayUnsorted[N] = {7,9,2,3,    4,5,1,8,    0,6};   //元素互为不同，且都是正数
    //int ArrayUnsorted[N] = {7,9,2,3,    4,5,2,8,    7,6};   //元素有重复，且都是正数
    //int ArrayUnsorted[N] = {7,9,-1,3,    4,5,-2,8,    -7,-6};    //元素有负数，且都是正数

    cout<<"the unsorted array is : "<<endl;
    DisplayArray(ArrayUnsorted,N);

    //测试SetContainerSort
    cout<<"Test SetContainerSort..."<<endl;
    SetContainerSort(ArrayUnsorted,N);
    cout<<"the sorted array is : "<<endl;
    DisplayArray(ArrayUnsorted,N);  

    return 0;
}

使用set或multiset容器，都可对不同类型的数进行排序，当然也可对含有负数的int数组排序。

因为set容器中的元素必须唯一，元素重复时会被忽略，所以使用set容器时，若输入元素有重复，利用set排序的结果会有丢失，在main中测试用第二行的数组时，运行结果如下：

the unsorted array is :
7       9       2       3       4       5       2       8       7       6

Test SetContainerSort...
the sorted array is :
2       3       4       5       6       7       8       9       7       6

请按任意键继续. . .

可以看到，set容器忽略了重复的元素，输出的7、6是原数组的元素。

若将使用的容器改为multiset，可正确排序，运行结果如下：

the unsorted array is :
7       9       2       3       4       5       2       8       7       6

Test SetContainerSort...
the sorted array is :
2       2       3       4       5       6       7       7       8       9

请按任意键继续. . .

---

 性能分析

结论：

BitmapSort_1是最快的，在数组长度为10,0000时，其速度比BitmapSort_2大概快一倍，应该是利用了STL中的bitset的优势，对bit的操作更快；
BitmapSort_2速度次之，qsort更次，而用set容器是最慢的，在数组成都为1000,0000时，性能的差别更为明显。

注意几点：

用clock()函数计时，分析时间性能，如下：

sortStartTime = clock();
 BitmapSort_2(ArrayUnsorted,numberOfRandomInt);
 TimeCost = 1e6 * ( clock() - sortStartTime ) / CLOCKS_PER_SEC;

通过程序运行前后的时间差，得到程序的运行时间。

栈内存是有限的，本程序中若数组长度为1000,0000如果在使用栈内存，程序运行时崩溃，单步跟踪，则会提示栈溢出，如下：

因此，在使用空间较大时，应在堆上分配内存，对于BitmapSort_2，将

int BitmapArray[1 + MaxRandomInt/BitsPerInt] = {0}; 

改为int *BitmapArray = new int[1 + MaxRandomInt/BitsPerInt]; 

并注意加上数组的初始化。

另外，对于位图排序，还应注意，最后for循环的结束条件是i < MaxRandomInt，而不是i < n,如下：

for (i = 0;i < MaxRandomInt;++i)  //不是for (i = 0;i < n;++i)
    {
        if ( IsBitSet(BitmapArray,i) )
        {
            ArrayUnsorted[cnt++] = i;
        }
    }

时间开销分析完整代码：

#include <iostream>
#include <bitset>
#include <set>
#include <ctime>
using namespace std;

const int MaxRandomInt = 10000000;
const int NumberToSort = 1000000;

//产生在区间[lowerBound,upperBound]内的一个随机数
int RandomInt(const int lowerBound,const int upperBound)
{
    return ( lowerBound + ( RAND_MAX * rand() + rand() ) % (upperBound - lowerBound + 1) );
}

//产生在[0,maxOfRandomInt]范围内的numberOfRandomInt个随机数
//结果存入数组randomInt中
void RandomIntGen(const int numberOfRandomInt,const int maxOfRandomInt,int randomInt[])
{
    int i;
    int tmp;
    int randomTmp;
    int *sequenceInt = new int[maxOfRandomInt];

    srand((unsigned) time(NULL));

    for (i = 0; i < maxOfRandomInt; i++)
    {
        sequenceInt[i] = i;    
    }

    for (i = 0; i < numberOfRandomInt; i++) 
    {
        randomTmp = RandomInt(i, maxOfRandomInt - 1);
        tmp = sequenceInt[randomTmp];
        sequenceInt[randomTmp] = sequenceInt[i];
        sequenceInt[i] = tmp;
        randomInt[i] = sequenceInt[i];    //随机数保存在数组中
    }

    delete [] sequenceInt;   //释放内存
}

//BitmapSort_1:用C++中模板类bitset实现的位图排序
void BitmapSort_1(int ArrayUnsorted[],int n)
{
    bitset <MaxRandomInt> Bitmap;
    int * ArraySorted = new int[n];
    int cnt = 0;
    Bitmap.reset();        //清零，保证使用之前全部为0

    int i ;
    for (i = 0;i < n;++i)     //标记各个位置
    {
        Bitmap.set(ArrayUnsorted[i]);
    }

    for (i = 0;i < n;++i)  
    {
        if ( Bitmap[i] )   //如果位置i为1，则说明i在数组ArraySorted中出现，且为排序后的第cnt个
        {
            ArrayUnsorted[cnt++] = i;
        }
    }
}

//不需要写初始化函数，因为在定义的时候可以初始化
void Init(int BitmapArray[],const int n)
{
    for (int i = 0;i < n;++i)
    {
        BitmapArray[i] = 0;
    }
}

//用int型模拟位图，实现的位图排序
const int BitsPerInt = 32;
const int Div32Shift = 5;
const int Mod32Mask = 0x1F;

//BitmapSort_2:用位运算实现置位、清零、判断是否为1
void SetBit(int BitmapArray[],const int BitToSet)
{
    //BitmapArray[ (BitToSet >> Div32Shift) ] | = ( 1 << (BitToSet & Mod32Mask) );  //error C2059: syntax error : '='
    BitmapArray[ (BitToSet >> Div32Shift) ] = BitmapArray[ (BitToSet >> Div32Shift) ] 
    | ( 1 << (BitToSet & Mod32Mask) ); 
}

void ClearBit(int BitmapArray[],const int BitToClear)
{
    BitmapArray[ (BitToClear >> Div32Shift) ] = BitmapArray[ (BitToClear >> Div32Shift) ] 
    & ~( 1 << (BitToClear & Mod32Mask) ); 
}

//bool IsBitSet(int BitmapArray[],const int BitToSet)
bool IsBitSet(const int BitmapArray[],const int BitToCheck)  //定义为const类型，在不小心改变时，会给出报错信息
{
    return ( BitmapArray[ (BitToCheck >> Div32Shift) ] & ( 1 << (BitToCheck & Mod32Mask) ) ); 
}

void BitmapSort_2(int ArrayUnsorted[],const int n)
{
    int i ;
    int cnt = 0;
    //int BitmapArray[1 + MaxRandomInt/BitsPerInt] = {0};   //将会初始化数组所有元素，而不只是第一个
    int *BitmapArray = new int[1 + MaxRandomInt/BitsPerInt];   //当MaxRandomInt较大时，必须从对上分配内存，否则内存不够用，导致出错
    
    if (NULL == BitmapArray)
    {
        cout<<"memory allocation error !"<<endl;
        exit(0);
    }

    Init(BitmapArray,1 + MaxRandomInt/BitsPerInt);   //初始化为0

    for (i = 0;i < n;++i)
    {
        SetBit(BitmapArray,ArrayUnsorted[i]);
    }

    /*for (i = 0;i < n;++i)
    {
        if ( IsBitSet(BitmapArray,i) )
        {
            ArrayUnsorted[cnt++] = i;
        }
    }*/

    for (i = 0;i < MaxRandomInt;++i)
    {
        if ( IsBitSet(BitmapArray,i) )
        {
            ArrayUnsorted[cnt++] = i;
        }
    }

    delete [] BitmapArray;
}

//没有加入合法性检查以及出错处理，只是实现了函数的功能
//使用C++ STL中的标准关联容器set排序
void SetContainerSort(int ArrayUnsorted[],int n)
{
    //set <int> SetForSort;            //使用set，元素不可重复
    //set <int> :: const_iterator iter = SetForSort.begin();
    multiset <int> SetForSort;        //使用multiset，元素可重复
    multiset <int> :: const_iterator iter = SetForSort.begin();
    int i;
    int cnt = 0;

    for (i = 0;i < n;++i)
    {
        SetForSort.insert(ArrayUnsorted[i]);
    }

    for (iter = SetForSort.begin();iter != SetForSort.end();++iter)
    {
        ArrayUnsorted[cnt++] = *iter;
    }
}


//注意参数必须为const类型
//int comp(void *_p,void *_q)    //提示cannot convert parameter 4 from 'int (__cdecl *)(void *,void *)' to 'int (__cdecl *)(const void *,const void *)'
int comp(const void *_p,const void *_q)
{
    int *p = (int *)_p;
    int *q = (int *)_q;
    return (*p - *q);
}

//显示数组元素
void DisplayArray(int ArrayUnsorted[],int n)
{
    for (int i = 0;i < n;++i)
    {
        cout<<ArrayUnsorted[i]<<"	";
    }
    cout<<endl;
}

void WriteArrayToUnsortedTxt(int array[],int n)
{
    FILE *fout;
    int i;

    fout = fopen("array_unsorted.txt","wt");

    if(fout == NULL)
    {
        printf("forward_i.txt open error!
");
        exit(0);
    }

    printf("file open success!
");

    for (i = 0;i < n;i++) 
    {
        fprintf(fout,"%d
",array[i]);
    }

    fclose(fout);    
}

void WriteArrayToSortedTxt(int array[],int n)
{
    FILE *fout;
    int i;

    fout = fopen("array_sorted.txt","wt");

    if(fout == NULL)
    {
        printf("forward_i.txt open error!
");
        exit(0);
    }

    printf("file open success!
");

    for (i = 0;i < n;i++) 
    {
        fprintf(fout,"%d
",array[i]);
    }

    fclose(fout);    
}

//测试程序
int main()
{
    const int numberOfRandomInt = NumberToSort;
    const int maxOfRandomInt = MaxRandomInt;
    int *ArrayUnsorted = new int[NumberToSort];
    int sortStartTime = 0;
    int TimeCost = 0;

    cout<<"the number of integer to sort is : "<<numberOfRandomInt<<endl;

    RandomIntGen(numberOfRandomInt,maxOfRandomInt,ArrayUnsorted);
    WriteArrayToUnsortedTxt(ArrayUnsorted,numberOfRandomInt);
    /*cout<<"the randomInt array is :"<<endl;
    DisplayArray(ArrayUnsorted,numberOfRandomInt);*/

    //测试BitmapSort_1
    /*cout<<"Test BitmapSort_1..."<<endl;

    sortStartTime = clock();
    BitmapSort_1(ArrayUnsorted,numberOfRandomInt);
    TimeCost = 1e6 * ( clock() - sortStartTime ) / CLOCKS_PER_SEC;
    cout<<"the time cost of BitmapSort_1 is : "<<TimeCost<<"ms"<<endl;

    WriteArrayToSortedTxt(ArrayUnsorted,numberOfRandomInt);*/
    /*cout<<"the sorted array is : "<<endl;
    DisplayArray(ArrayUnsorted,N);  */

    //测试BitmapSort_2
    cout<<"Test BitmapSort_2..."<<endl;

    sortStartTime = clock();
    BitmapSort_2(ArrayUnsorted,numberOfRandomInt);
    TimeCost = 1e6 * ( clock() - sortStartTime ) / CLOCKS_PER_SEC;
    cout<<"the time cost of BitmapSort_2 is : "<<TimeCost<<"ms"<<endl;

    WriteArrayToSortedTxt(ArrayUnsorted,numberOfRandomInt);
    /*cout<<"the sorted array is : "<<endl;
    DisplayArray(ArrayUnsorted,N);  */

    //测试SetContainerSort
    cout<<"Test SetContainerSort..."<<endl;

    sortStartTime = clock();
    SetContainerSort(ArrayUnsorted,numberOfRandomInt);
    TimeCost = 1e6 * ( clock() - sortStartTime ) / CLOCKS_PER_SEC;
    cout<<"the time cost of SetContainerSort is : "<<TimeCost<<"ms"<<endl;

    WriteArrayToSortedTxt(ArrayUnsorted,numberOfRandomInt);
    /*cout<<"the sorted array is : "<<endl;
    DisplayArray(ArrayUnsorted,N);  */

    //测试系统函数qsort
    cout<<"Test qsort..."<<endl;

    sortStartTime = clock();
    qsort(ArrayUnsorted,numberOfRandomInt,sizeof(int),comp);
    TimeCost = 1e6 * ( clock() - sortStartTime ) / CLOCKS_PER_SEC;
    cout<<"the time cost of qsort is : "<<TimeCost<<"ms"<<endl;

    WriteArrayToSortedTxt(ArrayUnsorted,numberOfRandomInt);
    /*cout<<"the sorted array is : "<<endl;
    DisplayArray(ArrayUnsorted,N);  */

    delete [] ArrayUnsorted;   //delete与new要配对出现

    return 0;
}

 对于用bitset容器的位图排序方法，由于bitset <MaxRandomInt> Bitmap;定义的Bitmap是在栈上的，当待排序数组长度为100,0000时，程序出错，提示栈溢出，因此采用数据个数为10，0000，分析，运行结果如下：

the number of integer to sort is : 100000
file open success!
Test BitmapSort_1...
the time cost of BitmapSort_1 is : 65000ms
file open success!
Test BitmapSort_2...
the time cost of BitmapSort_2 is : 120000ms
file open success!
Test SetContainerSort...
the time cost of SetContainerSort is : 4027000ms
file open success!
Test qsort...
the time cost of qsort is : 131000ms
file open success!
请按任意键继续. . .

对于其他三种方法，因为空间可以在堆上，待排序数组长度为1000,0000时，内存分配也不会出错，运行结果如下：

the number of integer to sort is : 1000000
file open success!
Test BitmapSort_2...
the time cost of BitmapSort_2 is : 869000ms
file open success!
Test SetContainerSort...
the time cost of SetContainerSort is : 39168000ms
file open success!
Test qsort...
the time cost of qsort is : 2200000ms
file open success!
请按任意键继续. . .

可以看到，BitmapSort_1是最快的，在数组长度为10,0000时，其速度比BitmapSort_2大概快一倍，应该是利用了STL中的bitset的优势，对bit的操作更快；
BitmapSort_2速度次之，qsort更次，而用set容器是最慢的，在数组成都为1000,0000时，性能的差别更为明显。