比较两种排序算法效率

        印象里冒泡法排序好像比一般交换法排序的效率高，今天突然想写个小程序比较一下这两种算法的效率。思路是随机生成大容量数组，然后分别用两种算法进行排序，排序前后分别提取系统时间，然后对前后得到的系统时间作差得到排序所用的时间。

程序中顺便用了一下STL中的一个排序算法，奇怪的是效率出奇地高，不知道是我用错了还是真的那么高，如果哪位大虾发现问题请务必告知，感激不尽！代码如下:

Code:

1. #include <iostream>   
2. #include <algorithm>   
3. #include <time.h>   
4. using namespace std;   
5.   
6. const size=60000;// 定义待排序数组大小   
7.   
8. bool init(int a[],int size) // 初始化   
9. {   
10.     srand(time(0));   
11.     for (int i=0;i<size;i++)   
12.     {   
13.         a[i]=rand();   
14.     }   
15.     return true;   
16. }   
17. bool sort1(int a[],int size) // 一般交换排序   
18. {   
19.     for (int i=0;i<size-1;i++)   
20.     {   
21.         for (int j=i+1;j<size;j++)   
22.         {   
23.             if (a[i]>a[j])   
24.             {   
25.                 int temp=a[i];   
26.                 a[i]=a[j];   
27.                 a[j]=temp;   
28.             }   
29.         }   
30.     }   
31.     return true;   
32. }   
33. bool sort2(int a[],int size)  // 冒泡排序   
34. {   
35.     for (int i=0;i<size-1;i++)   
36.     {   
37.         for (int j=size-1;j>i;j--)   
38.         {   
39.             if (a[j]<a[j-1])   
40.             {   
41.                 int temp=a[j];   
42.                 a[j]=a[j-1];   
43.                 a[j-1]=temp;   
44.             }   
45.         }   
46.     }   
47.     return true;   
48. }   
49. void disp(int a[],int size)   
50. {   
51.     for (int i=0;i<size;i++)   
52.     {   
53.         cout<<a[i]<<" ";   
54.     }   
55.     cout<<endl;   
56. }   
57. void main()   
58. {   
59.     time_t begin_time,end_time;   
60.     int a[size],b[size],c[size];   
61.     init(a,size);   
62.     init(b,size);   
63.     init(c,size);   
64.     cout<<"初始化完毕，开始排序……"<<endl;   
65.   
66.     begin_time=time(NULL);   
67.     sort1(a,size);   
68.     end_time=time(NULL);   
69.     cout<<"一般交换法用时"<<difftime(end_time,begin_time)<<"秒！"<<endl;   
70.   
71.     begin_time=time(NULL);   
72.     sort2(b,size);   
73.     end_time=time(NULL);   
74.     cout<<"冒泡法用时"<<difftime(end_time,begin_time)<<"秒！"<<endl;   
75.   
76.     begin_time=time(NULL);   
77.     sort(c,c+size);   
78.     end_time=time(NULL);   
79.     cout<<"STL的sort()用时"<<difftime(end_time,begin_time)<<"秒！"<<endl;   
80. //  disp(c,size);   
81. }   

 当数组容量为60000时，执行结果如下：

结果与实际不符，我也不知道为什么。