
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("
");
}
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_H32
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
do117
{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
else189
{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
else219
{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("
");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
}