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

最新推荐文章于 2021-08-02 08:55:00 发布

JohnnyHu90

最新推荐文章于 2021-08-02 08:55:00 发布

阅读量1.8k

点赞数

分类专栏：编程珠玑

本文链接：https://blog.csdn.net/johnnyhu90/article/details/11720893

版权

编程珠玑专栏收录该内容

31 篇文章 3 订阅

订阅专栏

首先利用“编程珠玑之习题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;

}

输出结果：