Chapter 9 (排序)
![](https://images2018.cnblogs.com/blog/1287367/201807/1287367-20180717222611907-368903974.jpg)
1.排序算法:
//****************************Sort.h********************************************
#ifndef SORT_H
#define SORT_H
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
//冒泡排序
void BubbleSort(int data[],int len);
//简单选择排序
void SelectSort(int data[],int len);
//直接插入排序
void InsertSort(int data[],int len);
//希尔排序
void ShellSort(int data[],int len);
//堆排序
void HeapSort(int data[],int len);
//归并排序
void MergeSort(int data[],int len);
//快速排序
void QuickSort(int data[],int len);
#endif //SORT_H
//****************************Sort.c********************************************
#include "Sort.h"
void swap(int a[],int i,int j)
{
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
//冒泡排序
void BubbleSort(int data[],int len)
{
int i,j;
bool flag;
for(i=0;i < len-1;i++)
{
flag = false;
for(j = len-1;j >i;j--)
{
if(data[j] < data[j-1])
{
swap(data,j,j-1);
}
}
if(!flag) //标志位未被置位,序列已经有序
{
break;
}
}
}
//简单选择排序
void SelectSort(int data[],int len)
{
int i,j,min;
for(i=0;i < len;i++)
{
min = i;
for(j=i+1;j < len;j++)
{
if(data[j] < data[min])
{
min = j;
}
}
if(min != i)
{
swap(data,i,min);
}
}
}
//直接插入排序
void InsertSort(int data[],int len)
{
int i,j;
for(i=1;i < len;i++)
{
if(data[i] < data[i-1])
{
int tmp = data[i];
for(j= i-1;j >= 0 && data[j] > tmp;j--)
{
data[j+1] = data[j];
}
data[j+1] = tmp;
}
}
}
//希尔排序
void ShellSort(int data[],int len)
{
int increment = len;
int i,j;
do
{
increment = increment/3+1;
for(i=increment+1;i < len;i++)
{
if(data[i] < data[i-increment])
{
int tmp = data[i];
for(j= i-increment;j >= 0 && data[j] > tmp ;j-=increment)
{
data[j+increment] = data[j];
}
data[j+increment] = tmp;
}
}
}
while(increment>1);
}
void HeapAdjust(int data[],int s,int m)
{
int i,tmp;
tmp = data[s];
for(i=2*s;i <= m;i*=2)
{
if(i<m && data[i] < data[i+1])
{
++i;
}
if(tmp >= data[i])
{
break;
}
data[s] = data[i];
s = i;
}
data[s] = tmp;
}
//堆排序
void HeapSort(int data[],int len)
{
int i;
for(i=len/2;i >= 0;i--)
{
HeapAdjust(data,i,len-1);
}
for(i=len-1;i > 0;i--)
{
swap(data,0,i);
HeapAdjust(data,0,i-1);
}
}
void Merge(int data[],int tmp[],int s,int m,int t)
{
int j,k,l;
for(j=m+1,k=s;j<=t && s<=m;k++)
{
if(data[s] < data[j])
{
tmp[k] = data[s++];
}
else
{
tmp[k] = data[j++];
}
}
if(s <= m)
{
for(l=0;l <= m-s;l++)
{
tmp[k+l] = data[s+l];
}
}
if(j <= t)
{
for(l=0;l <= t-j;l++)
{
tmp[k+l] = data[j+l];
}
}
}
void MSort(int data[],int tmp[],int s,int t)
{
int tmp1[1000];
int m;
if(s == t)
{
tmp[s] = data[s];
}
else
{
m = (s+t)/2;
MSort(data,tmp1,s,m);
MSort(data,tmp1,m+1,t);
Merge(tmp1,tmp,s,m,t);
}
}
//归并排序
void MergeSort(int data[],int len)
{
MSort(data,data,0,len-1);
}
int Partition(int data[],int low,int high)
{
int key = data[low];
while(low < high)
{
while(low<high && data[high] > key)
{
high--;
}
data[low] = data[high];
while(low <high && data[low] < key)
{
low++;
}
data[high] = data[low];
}
data[low] = key;
return low;
}
void QSort(int data[],int low,int high)
{
int pivot;
if(low <high)
{
pivot = Partition(data,low,high);
QSort(data,low,pivot-1);
QSort(data,pivot+1,high);
}
}
//快速排序
void QuickSort(int data[],int len)
{
QSort(data,0,len-1);
}
//****************************SortTest.c********************************************
#include "Sort.h"
void travel(int a[],int n)
{
for(int i=0;i < n;i++)
{
printf("%d ",a[i]);
}
printf("\n");
}
int main()
{
int a[] = {2,6,8,5,4,10,1,3,7,9};
travel(a,10);
//冒泡排序
//BubbleSort(a,10);
//简单选择排序
//SelectSort(a,10);
//直接插入排序
//InsertSort(a,10);
//希尔排序
//ShellSort(a,10);
//堆排序
//HeapSort(a,10);
//归并排序
//MergeSort(a,10);
//快速排序
QuickSort(a,10);
travel(a,10);
}
x
273
1
//****************************Sort.h********************************************
2
3
4
5
6
7
8
9
//冒泡排序
10
void BubbleSort(int data[],int len);
11
12
//简单选择排序
13
void SelectSort(int data[],int len);
14
15
//直接插入排序
16
void InsertSort(int data[],int len);
17
18
//希尔排序
19
void ShellSort(int data[],int len);
20
21
//堆排序
22
void HeapSort(int data[],int len);
23
24
//归并排序
25
void MergeSort(int data[],int len);
26
27
//快速排序
28
void QuickSort(int data[],int len);
29
30
31
//SORT_H
32
33
34
//****************************Sort.c********************************************
35
36
37
void swap(int a[],int i,int j)
38
{
39
int tmp = a[i];
40
a[i] = a[j];
41
a[j] = tmp;
42
}
43
44
//冒泡排序
45
void BubbleSort(int data[],int len)
46
{
47
int i,j;
48
bool flag;
49
for(i=0;i < len-1;i++)
50
{
51
flag = false;
52
for(j = len-1;j >i;j--)
53
{
54
if(data[j] < data[j-1])
55
{
56
swap(data,j,j-1);
57
}
58
59
}
60
if(!flag) //标志位未被置位,序列已经有序
61
{
62
break;
63
}
64
}
65
}
66
67
//简单选择排序
68
void SelectSort(int data[],int len)
69
{
70
int i,j,min;
71
for(i=0;i < len;i++)
72
{
73
min = i;
74
for(j=i+1;j < len;j++)
75
{
76
if(data[j] < data[min])
77
{
78
min = j;
79
}
80
}
81
if(min != i)
82
83
{
84
swap(data,i,min);
85
}
86
}
87
88
}
89
90
//直接插入排序
91
void InsertSort(int data[],int len)
92
{
93
int i,j;
94
95
for(i=1;i < len;i++)
96
{
97
if(data[i] < data[i-1])
98
{
99
int tmp = data[i];
100
for(j= i-1;j >= 0 && data[j] > tmp;j--)
101
{
102
data[j+1] = data[j];
103
}
104
data[j+1] = tmp;
105
}
106
107
}
108
}
109
110
//希尔排序
111
void ShellSort(int data[],int len)
112
{
113
int increment = len;
114
int i,j;
115
116
do
117
{
118
increment = increment/3+1;
119
120
for(i=increment+1;i < len;i++)
121
{
122
if(data[i] < data[i-increment])
123
{
124
int tmp = data[i];
125
126
for(j= i-increment;j >= 0 && data[j] > tmp ;j-=increment)
127
{
128
data[j+increment] = data[j];
129
}
130
data[j+increment] = tmp;
131
}
132
}
133
134
}
135
while(increment>1);
136
}
137
138
void HeapAdjust(int data[],int s,int m)
139
{
140
int i,tmp;
141
tmp = data[s];
142
for(i=2*s;i <= m;i*=2)
143
{
144
if(i<m && data[i] < data[i+1])
145
{
146
++i;
147
}
148
149
if(tmp >= data[i])
150
{
151
break;
152
}
153
data[s] = data[i];
154
s = i;
155
}
156
data[s] = tmp;
157
}
158
159
160
//堆排序
161
void HeapSort(int data[],int len)
162
{
163
int i;
164
for(i=len/2;i >= 0;i--)
165
{
166
HeapAdjust(data,i,len-1);
167
}
168
169
170
for(i=len-1;i > 0;i--)
171
{
172
swap(data,0,i);
173
HeapAdjust(data,0,i-1);
174
}
175
}
176
177
178
void Merge(int data[],int tmp[],int s,int m,int t)
179
{
180
int j,k,l;
181
182
for(j=m+1,k=s;j<=t && s<=m;k++)
183
{
184
if(data[s] < data[j])
185
{
186
tmp[k] = data[s++];
187
}
188
else
189
{
190
tmp[k] = data[j++];
191
}
192
}
193
if(s <= m)
194
{
195
for(l=0;l <= m-s;l++)
196
{
197
tmp[k+l] = data[s+l];
198
}
199
}
200
201
if(j <= t)
202
{
203
for(l=0;l <= t-j;l++)
204
{
205
tmp[k+l] = data[j+l];
206
}
207
}
208
}
209
210
void MSort(int data[],int tmp[],int s,int t)
211
{
212
int tmp1[1000];
213
int m;
214
if(s == t)
215
{
216
tmp[s] = data[s];
217
}
218
else
219
{
220
m = (s+t)/2;
221
MSort(data,tmp1,s,m);
222
MSort(data,tmp1,m+1,t);
223
Merge(tmp1,tmp,s,m,t);
224
}
225
}
226
//归并排序
227
void MergeSort(int data[],int len)
228
{
229
MSort(data,data,0,len-1);
230
}
231
232
233
int Partition(int data[],int low,int high)
234
{
235
int key = data[low];
236
237
while(low < high)
238
{
239
while(low<high && data[high] > key)
240
{
241
high--;
242
}
243
data[low] = data[high];
244
245
while(low <high && data[low] < key)
246
{
247
low++;
248
}
249
data[high] = data[low];
250
}
251
data[low] = key;
252
return low;
253
}
254
255
void QSort(int data[],int low,int high)
256
{
257
int pivot;
258
259
if(low <high)
260
{
261
pivot = Partition(data,low,high);
262
QSort(data,low,pivot-1);
263
QSort(data,pivot+1,high);
264
}
265
}
266
267
//快速排序
268
void QuickSort(int data[],int len)
269
{
270
QSort(data,0,len-1);
271
}
272
273
//****************************SortTest.c********************************************
274
275
276
void travel(int a[],int n)
277
{
278
for(int i=0;i < n;i++)
279
{
280
printf("%d ",a[i]);
281
}
282
printf("\n");
283
}
284
285
int main()
286
{
287
int a[] = {2,6,8,5,4,10,1,3,7,9};
288
travel(a,10);
289
290
//冒泡排序
291
//BubbleSort(a,10);
292
293
//简单选择排序
294
//SelectSort(a,10);
295
296
297
//直接插入排序
298
//InsertSort(a,10);
299
300
//希尔排序
301
//ShellSort(a,10);
302
303
//堆排序
304
//HeapSort(a,10);
305
306
//归并排序
307
//MergeSort(a,10);
308
309
310
//快速排序
311
QuickSort(a,10);
312
travel(a,10);
313
}
附件列表