编程珠玑之第一章习题3:度量100w整数排序的运行时间

首先利用“编程珠玑之习题1.4: 生成不同的随机顺序的随机整数及存储与读取”给出的生成随机数的方法，在1000w整数的范围内生成100w个随机数；这里生成的随机数文件是unsortfile.txt文件，排序后的文件是sortedfile.txt

1.C++STL(vector, sort)进行排序：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

// 测试C++库的sort结合vector给100w整数排序耗时情况
#include <iostream>
#include <fstream>
#include <ctime>       /* time */
#include <algorithm>
#include <vector>

#define Error( str )        FatalError( str )
#define FatalError( str )   fprintf( stderr, "%s\n", str ), exit( 1 )
#define N 10000000

using namespace std;

int main ()
{
    vector<int> vec;

    ifstream infile;
    infile.open("unsortfile.txt");
    if (!infile)
        FatalError("不能打开unsortfile.txt文件！\n");

    // 从文件中读取数据
    clock_t starTtime = clock();// 开始时间 
    int index = 0, nValue = 0;  
    
    infile >> nValue; 
    //while(infile.peek() != EOF)   // 不变式：此时已经得到index个数
    while(!infile.eof()) // peek()和efo()都工作
    {
        index++;
        vec.push_back(nValue);

        infile >> nValue;
    }

    infile.close();
    clock_t endTimeRead = clock();

    sort(vec.begin(), vec.end());
    clock_t endTimeSort = clock();

    ofstream outfile;
    outfile.open("sortedfile.txt");
    if (!outfile)
        FatalError("不能打开sortedfile.txt文件！\n");

    for (int i=0; i != vec.size(); ++i)
    {
        outfile << vec[i] << "\t";
    }
    outfile.close();
    clock_t endTimeWrite  = clock();    // 结束时间

    float readTime = (float)(endTimeRead - starTtime) / CLOCKS_PER_SEC; // secs
    float sortTime = (float)(endTimeSort- endTimeRead) / CLOCKS_PER_SEC; 
    float writeTime = (float)(endTimeWrite- endTimeSort) / CLOCKS_PER_SEC; 

    cout << "文件中的记录数："  << vec.size() << endl;
    cout << "读文件耗时："    << readTime << endl;
    cout << "文件排序耗时："   << sortTime << endl;
    cout << "写文件耗时："    << writeTime << endl;

    return 0;
}

输出结果：

2. C库函数qsort给100W排序：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

//测试C库的qSort给100w整数排序耗时情况
#include <stdio.h>
#include <stdlib.h>     /* qsort */
#include <time.h>       /* time, clock_t*/
#include <assert.h>     /* assert */
#include <string.h>     /* memset*/

#define Error( str )        FatalError( str )
#define FatalError( str )   fprintf( stderr, "%s\n", str ), exit( 1 )
#define N 10000000

int intcomp (const void * a, const void * b)
{
    return ( *(int*)a - *(int*)b );
}

int main()
{

    int arr[N];
    memset(arr, 0, sizeof(arr));// 数组a清零

    FILE* iofile;
    if ( NULL == (iofile = fopen("unsortfile.txt", "r")) )
        FatalError("不能打开unsortfile.txt文件！\n");

    // 从文件中读取数据
    clock_t starTtime = clock();// 开始时间 
    int index = 0;      
    while(fscanf(iofile, "%d", &arr[index]) != EOF)
    {
        index++;
    }
    fclose(iofile);
    clock_t endTimeRead = clock();

    qsort(arr, index, sizeof(int), intcomp);

    clock_t endTimeSort = clock();
    if ( NULL == (iofile = fopen("sortedfile.txt", "w")) )
        FatalError("不能打开sortedfile.txt文件！\n");

    for (int i = 0; i < index; i++)
    {
        fprintf(iofile, "%d\t", arr[index]);
    }
    fclose(iofile);

    clock_t endTimeWrite  = clock();    // 结束时间
    float   readTime = (float)(endTimeRead - starTtime) / CLOCKS_PER_SEC; // secs
    float   sortTime = (float)(endTimeSort- endTimeRead) / CLOCKS_PER_SEC; 
    float   writeTime = (float)(endTimeWrite- endTimeSort) / CLOCKS_PER_SEC; 

    printf("文件中的记录数：%d\n", index);
    printf("读文件耗时：  %5.3f秒\n", readTime);
    printf("文件排序耗时：%5.3f秒\n", sortTime);
    printf("写文件耗时：  %5.3f秒\n", writeTime);

    return 0;

}

输出结果：

3. 利用位图排序情况：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

 #include <stdio.h>
 #include <stdlib.h>        /* srand, rand */
 #include <time.h>      /* time, clock_t*/
 #include <assert.h>     /* assert */
 #include <string.h>        /* memset*/
 
 #define Error( str )        FatalError( str )
 #define FatalError( str )   fprintf( stderr, "%s\n", str ), exit( 1 )
 
 #define BITSPERWORD 32
 #define SHIFT 5
 #define MASK 0x1F
 #define N 10000000
 int a[1 + N/BITSPERWORD];
 
 void set(int i)
 { 
    a[i>>SHIFT] |= (1<<(i & MASK)); 
    return;
 }
 
 void clr(int i)    // 初始化清零
 {        
    a[i>>SHIFT] &= ~(1<<(i & MASK)); // 逐次将32为值清零
 }
 
 int test(int i)    // 测试逻辑位置为n的二进制位是否为1 
 { 
    return a[i>>SHIFT] & (1<<(i & MASK)); 
 }
 
 int main()
 {
    FILE* iofile;
    for (int i = 0; i < N; i++)
        clr(i);
 
    //Replace above 2 lines with below 3 for word-parallel init
    //  int top = 1 + N/BITSPERWORD;
    //  for (i = 0; i < top; i++)
    //      a[i] = 0;
 
    if ( NULL == (iofile = fopen("unsortfile.txt", "r")) )
        FatalError("不能打开unsortfile.txt文件！\n");
 
    clock_t starttime = clock();// 开始时间
    // 从文件中读取数据 
    int index = 0, nValue;
    while(fscanf(iofile, "%d", &nValue) != EOF)
    {
        set(nValue);
        index++;
    }
 
    fclose(iofile);
    clock_t endtime1 = clock();
 
 
    if ( NULL == (iofile = fopen("sortedfile.txt", "w")) )
        FatalError("不能打开unsortfile.txt文件！\n");
 
    for (int i = 0; i < N; i++)
    {
        if (test(i))
            fprintf(iofile, "%d\t", i);
    }
    fclose(iofile);
 
    clock_t endtime2  = clock();    // 结束时间
    float   costTime1 = (float)(endtime1 - starttime) / CLOCKS_PER_SEC; // secs
    float   costTime2 = (float)(endtime2 - endtime1) / CLOCKS_PER_SEC; 
 
    printf("文件中的记录数：%d\n", index);
    printf("读文件耗时：%5.3f秒\n", costTime1);
    printf("写文件耗时：%5.3f秒\n", costTime2);
 
    return 0;
 
 }

输出结果：

从以上来看，利用vector来排序效果最差，其实我们可以再试一下list和set对这100w数据的排序，效果应该会优于vector，以后有时间再测！！！