1）“冒泡法”
冒泡法大家都较熟悉。其原理为从a[0]开始，依次将其和后面的元素比较,
若a[0]>a[i]，则交换它们，一直比较到a[n]。
同理对a[1],a[2],...a[n-1]处理，即完成排序。
void bubble(int *a,int n) /*定义两个参数：数组首地址与数组大小*/
{
int i,j,temp;
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++) /*注意循环的上下限*/
if(a[i]>a[j])
{
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
冒泡法原理简单，但其缺点是交换次数多，效率低。
下面介绍一种源自冒泡法但更有效率的方法“选择法”。
（2）“选择法”
选择法循环过程与冒泡法一致，它还定义了记号k=i
然后依次把a[k]同后面元素比较，若a[k]>a[j],则使k=j.
最后看看k=i是否还成立，不成立则交换a[k],a[i]
这样就比冒泡法省下许多无用的交换，提高了效率。
void choise(int *a,int n)
{
int i,j,min,temp;
for(i=0;i<n-1;i++)
{
min=i; /*给记号赋值*/
for(j=i+1;j<n;j++)
{
if(a[min]>a[j])
min=j; /*是k总是指向最小元素*/
}
if(i!=min)
{ /*当k!=i是才交换，否则a[i]即为最小*/
temp=a[i];
a[i]=a[min];
a[min]=temp;
}
}
}
选择法比冒泡法效率更高，但说到高效率，非“快速法”莫属，现在就让我们来了解它。
（3）“快速法”
快速法定义了三个参数,（数组首地址*a,要排序数组起始元素下标i,要排序数组结束元素下标j).
它首先选一个数组元素（一般为a[ (i+j)/2 ],即中间元素）作为参照,把比它小的元素放到它的左边，比它大的放在右边。
然后运用递归，在将它左，右两个子数组排序，最后完成整个数组的排序。
下面分析其代码：
void quick(int *a,int i,int j)
{
int m,n,temp;
int k;
m=i;
n=j;
k=a[(i+j)/2]; /*选取的参照*/
do
{
while( a[m]<k && m<j )
m++; /* 从左到右找比k大的元素*/
while( a[n] >k && n>i )
n--; /* 从右到左找比k小的元素*/
if(m<=n)
{ /*若找到且满足条件，则交换*/
temp=a[m];
a[m]=a[n];
a[n]=temp;
m++;
n--;
}
}
while(m<=n);
if(m<j)
quick(a,m,j); /*运用递归*/
if(n>i)
quick(a,i,n);
}
（4）“插入法”
插入法是一种比较直观的排序方法。
它首先把数组头两个元素排好序，再依次把后面的元素插入适当的位置。
把数组元素插完也就完成了排序。
void insert(int *a,int n)
{
int i,j,temp;
for(i=1;i<n;i++)
{
temp=a[i]; /*temp为要插入的元素*/
j=i-1;
while( j>=0&&temp<a[j] )
{ /*从a[i-1]开始找比a[i]小的数，同时把数组元素向后移*/
a[j+1]=a[j];
j--;
}
a[j+1]=temp; /*插入*/
}
}
（5）“shell法”
shell法是一个叫 shell 的美国人与1969年发明的。
它首先把相距k(k>=1)的那几个元素排好序，再缩小k值（一般取其一半），再排序，直到k=1时完成排序。
下面让我们来分析其代码：
void shell(int *a,int n)
{
int i,j,k,x;
k=n/2; /*间距值*/
while(k>=1)
{
for(i=k;i<n;i++)
{
x=a[i];
j=i-k;
while(j>=0&&x<a[j])
{
a[j+k]=a[j];
j-=k;
}
a[j+k]=x;
}
k/=2; /*缩小间距值*/
}
}
http://814193594.blog.51cto.com/10729329/1715944
|
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
|
/*
** bubble sort
*/
void
bubble_sort(
int
*str,
int
size)
{
int
i = 0, j = 0;
int
tmp = 0;
/*
** 进行size-1趟排序；
*/
for
(i = 0; i < size - 1; i++)
{
/*
** 每排序一趟，将最大的元素沉底。下一趟少比较i次；
*/
for
(j = 0; j < size - 1 - i; j++)
{
if
(str[j] > str[j + 1])
{
tmp = str[j];
str[j] = str[j + 1];
str[j + 1] = tmp;
}
}
}
}
/*
** 优化一：设置一个标志位sign的bubble sort；
*/
void
bubble_sort(
int
*str,
int
size)
{
int
i = 0, j = 0;
int
tmp = 0, sign = 0;
for
(i = 0; i < size - 1; i++)
{
/*
** 每趟排序前将sign置为0，如果相邻元素进行了交换则sign>1;
** 否则，sign==0，没有进行交换，排序完成，跳出循环；
*/
flag = 0;
for
(j = 0; j < size - 1 - i; j++)
{
if
(str[j] > str[j + 1])
{
tmp = str[j];
str[j] = str[j + 1];
str[j + 1] = tmp;
sign++;
}
}
if
(0 == sign)
break
;
}
}
/*
** 优化二：quick sort；
*/
void
quicksort(
int
*str,
int
left,
int
right)
{
assert
(str);
/*
**如果左边大于或等于右边，则该数组已经排序完成；
*/
if
(left >= right)
{
return
;
}
int
i = left;
int
j = right;
int
key = str[left];
/*
**当i=j时，一趟排序完成，将所有数分为一大一小两组；
*/
while
(i < j)
{
/*
**第一次从后向前遍历，遇到第一个比key小的交换两数位置；
*/
while
((i < j) && (key <= str[j]))
{
j--;
}
str[i] = str[j];
/*
**第二次从前向后遍历，遇到第一个比key大的交换两数位置；
*/
while
((i < j) && (key >= str[i]))
{
i++;
}
str[j] = str[i];
}
str[i] = key;
/*
**递归调用，完成左、右子序列的排序；
*/
quicksort(str, left, i - 1);
quicksort(str, i + 1, right);
}
|
705
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
