选择和冒泡
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
|
#include<stdio.h>
void maopao( int a[], int len){
int i,j,temp;
for (i = 0;i < len - 1 ; i ++){ //从第一个到倒数第二个
for (j = 0 ; j < len - 1 - i ; j ++) //排在后的是已经排序的
{
if (a[j] > a[j + 1]) //大的数换到后面去
{
temp = a[j];
a[j] = a[j + 1];
a [j + 1] = temp;
}
}
}
}
void xuanze( int a[], int len){
int i , j , t , temp;
for (i = 0 ; i < len - 1 ;i ++)
{
t = i;
for (j = i + 1 ; j < len ; j ++) //前面的实排好的
{
if (a[t] > a[j])
{
t = j; //记下该趟最小数的序号
}
}
if (t != i) //如果序号不变就什么也不做
{
temp = a[t]; //否则元素交换
a[t] = a[i];
a[i] = temp;
}
}
}
void main(){
int i;
int a[] = {5,4,6,7,2,5,4,6,8,9,1,2};
//maopao(a, 12);
xuanze(a, 12);
for (i = 0 ; i < 12 ; i ++)
{
printf ( "%d " ,a[i]);
}
}
|
快速排序与冒泡、选择的比较:
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
#include <stdio.h>
#include <time.h>
#include <windows.h>
//快速排序,参数是数组,最低索引,最高索引(从0开始)
void qSort( int a[], int low, int high){
int temp;
int mid = low; //定义一个中索引,用于记录一次排序后确定位置的一个元素索引
int right = high; //记录最右元素索引
//默认中值是左值,现在要把凡是比中值大的元素放到中值左边
while (right > mid){ //因此从右开始向中值遍历,到达中值时遍历结束
if (a[right] < a[mid]) //如果右值比中值还小,说明他不该在右边,要把它放到左边
{
temp = a[mid]; //所以先把中值的地盘腾出来
a[mid] = a[right]; //把比中值小的那个数放在那儿
//中值没地方放,必须右移移位,但是直接右移会覆盖原来他右边的那个值
a[right] = a[++mid]; //不过right索引的空间已经腾出来了,就把中值原来右边的值放到right
a[mid] = temp; //然后就可以把mid右移一位
}
else {
right--; //否则的话说明right已然大于等于mid,不用移动,继续判断right左边那个数
}
} //这样right与mid重合之时,退出循环,此时mid的位置已经确定了就是排完序后他的位置
//因为他左边的都比他小,右边的都比他大
if (mid - low > 1) //如果low到mid之间还有两个或以上元素,还要对他们排序
{
qSort(a, low, mid - 1);
}
if (high - mid > 1) //右边那半也是一样
{
qSort(a, mid + 1, high);
}
}
void sSort( int a[], int len){ //选择排序,参数是数组名和元素个数
int i, j, m, temp;
for (i = 0; i < len - 1; i++) //从开始到倒数第二个元素
{
m = i; //先记录最左边的元素索引,假设他为最小
for (j = i + 1; j < len; j++) //从左往右遍历一直到最后
{
if (a[j] < a[m]) //如果发现更小的元素
{
m = j; //记下这个元素的索引
}
}
if (m != i) //如果最小的元素不是开始那个,就需要把最小的换到最左边
{
temp = a[i];
a[i] = a[m];
a[m] = temp;
}
}
}
void mSort( int a[], int len){ //冒泡法排序,参数是数组名,元素个数
int i, j, temp;
for (i = 0; i < len - 1; i ++) //从开始到倒数第二个元素
{
for (j = 0; j < len - 1 - i; j++) //从头遍历到已序队列往前第二个
{
if (a[j] > a[j + 1]) //如果元素比他的后一个大,则交换
{
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
} //一次遍历后最大元素放到最后面
}
}
int checkSorted( int a[], int len){ //检查数组排序是否已经正确
int i;
for (i = 0; i < len - 1; i++)
{
if (a[i] > a[i + 1]) //如果一个元素比他的下一个还要大,说明发生错误
{
return 0;
}
}
return 1;
}
void main(){
int i, j;
int a[99999];
clock_t begin, end;
double cost;
for (j = 0; j < 6; j++) //做6次测试
{
srand (( int ) time (0)); //用时间做种,是每次数字都不同
for (i = 0; i < 99999; i++)
{
a[i] = rand (); //产生随机数放入数组
}
begin = clock ();
//qSort(a, 0, 99998);//1秒左右
//sSort(a, 99999);//20秒左右
mSort(a, 99999); //40秒左右
end = clock ();
for (i = 0; i < 12; i++) //输出前面的几个排好序的元素
{
printf ( "%d " , a[i]);
}
cost = ( double )(end - begin) / CLOCKS_PER_SEC; //计算排序时间
printf ( "...\t排序用时 %lf 秒 " , cost); //输出排序所用时间
if (checkSorted(a, 99999)) //检查排序是否正确
{
printf ( "正确!\n" );
} else {
printf ( "有错!\n" );
}
Sleep(1200); //暂停一下,使每次时间种子不同
}
}
|
1. 快速排序的结果:
99999个随机数一般不超过0.05秒,很快
2.选择法排序结果:
99999个随机数一般不超过0.05秒,很快
2.选择法排序结果:
一般在20多秒;
3.冒泡法,一般情况下交换的次数会很多,结果:
排序时间一般在50秒左右,最慢。
在C++中,还可以定义函数模板
因为快速排序通常很快,所以用它来对不同的数据类型排序
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
|
#include <iostream.h>
template < class T> void qSort(T a[], int low, int high){ //在C++中,可以定义函数模板
T temp;
int mid = low;
int right = high;
while (right > mid)
{
if (a[right] < a[mid])
{
temp = a[mid];
a[mid] = a[right];
a[right] = a[++mid];
a[mid] = temp;
} else {
right--;
}
}
if (mid - low > 1)
{
qSort(a, low, mid - 1);
}
if (high - mid > 1)
{
qSort(a, mid + 1, high);
}
}
void main(){
int a[10] = {1, 9, 6, 3, 5, 7, 1}; //有了一个函数模板,可以对整型排序
qSort(a, 0, 9);
for ( int i = 0; i < 10; i++)
{
cout<<a[i]<< " " ;
}
cout<<endl;
float b[10] = {2.0f, 1.2f, 5.5f, 6.63f, 9.11f, 1.32f, 3.44f, 5.0f, 5.22f, 0.02f};
qSort(b, 0, 9); //对浮点数排序
for (i = 0; i < 10; i++)
{
cout<<b[i]<< " " ;
}
cout<<endl;
char c[10] = { 'd' , 'e' , 'f' , 'n' , 'j' , 'c' , 'e' , 'b' , 'f' , 'a' }; //对字符数组排序
qSort(c, 0, 9);
for (i = 0; i < 10; i++)
{
cout<<c[i]<< " " ;
}
cout<<endl;
} //凡是可以用‘<'来比较大小的类型都可以排序了
|