Chapter 9 (排序)
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
#ifndef SORT_H
3
#define SORT_H
4
5
#include <stdio.h>
6
#include <stdlib.h>
7
#include <stdbool.h>
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
#endif //SORT_H
32
33
34
//****************************Sort.c********************************************
35
#include "Sort.h"
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
#include "Sort.h"
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
}
附件列表
Chapter 9 (排序)的更多相关文章
- Chapter 6 排序
Chapter 6 排序 1- 直接插入排序 O(n2) O(1) 2- 折半插入排序 O(n2) O(1) 适合关键字较多 3- 希尔排序O(nlogn) O(1) 又名,缩小增量排序 ...
- 《算法导论》 — Chapter 7 高速排序
序 高速排序(QuickSort)也是一种排序算法,对包括n个数组的输入数组.最坏情况执行时间为O(n^2). 尽管这个最坏情况执行时间比較差.可是高速排序一般是用于排序的最佳有用选择.这是由于其平均 ...
- MySQL Crash Course #03# Chapter 5. 6 排序. BETWEEN. IS NULL
索引 排序检索的数据 SQL 过滤 vs. 应用程序过滤 简单 Where 补充:大小写敏感. BETWEEN. IS NULL Sorting Retrieved Data mysql> SE ...
- 《算法导论》 — Chapter 8 线性时间排序
序 到目前为止,关于排序的问题,前面已经介绍了很多,从插入排序.合并排序.堆排序以及快速排序,每一种都有其适用的情况,在时间和空间复杂度上各有优势.它们都有一个相同的特点,以上所有排序的结果序列,各个 ...
- Chapter 5. Label and Entry Widgets 标签和输入部件
Chapter 5. Label and Entry Widgets 标签和输入部件 有时候,你需要用户输入特定的信息,比如他们的名字,地址或者 甚至序号. 简单的方式来实现这个是使用Enry 部件 ...
- 利用ArrayList对Hashtable其进行排序
前言: 最近在使用Hashtable的时候发现一个问题:就是当你对Hashtable进行遍历的时候整个输出结果是毫无顺序的, 上网查了一下说是Hashtable有自己内部的排序机制,如果要自定义排序的 ...
- Chapter 1 Securing Your Server and Network(8):停止未使用的服务
原文:Chapter 1 Securing Your Server and Network(8):停止未使用的服务 原文出处:http://blog.csdn.net/dba_huangzj/arti ...
- MVC 5 的 EF6 Code First 入门 系列：排序、筛选和分页
这是微软官方SignalR 2.0教程Getting Started with Entity Framework 6 Code First using MVC 5 系列的翻译,这里是第三篇:排序.筛选 ...
- Java温故而知新-冒泡法排序
冒泡法排序是各种初学者在学习数组与循环结构时都会练习的一种简单排序算法. 冒泡法的精髓在于比较相邻的两个元素,较大的元素会不断的排到队伍后面去,就像水里的泡泡一样不断向上跑. 想像一下倒在一个透明玻璃 ...
随机推荐
- POJ3278&&1426&&3126&&3087&&3414
接上次的,标签是BFS专题 其实无论是Deepth还是Breadth都是Search 3278 又是撸过的题目 1426 找一个十进制数(我刚开始看样例以为是二进制数),使得它每一位上都是1或0,且是 ...
- switch语句的执行过程
switch语句的执行规则如下: 1.从第一个case开始判断,不匹配则跳到下一个case继续判断: 2.遇到break则跳出switch语句: 3.default一般是没有匹配项才执行的,一般是放在 ...
- 【第七课】Nginx反向代理和负载均衡
目录 一.Nginx负载均衡集群 介绍 二.实现一个简单的负载均衡 三.Nginx负载均衡组件介绍 四.Nginx负载均衡实际应用 一.Nginx负载均衡集群 介绍 负载均衡(Load Balance ...
- [CF587F]Duff is Mad[AC自动机+根号分治+分块]
题意 给你 \(n\) 个串 \(s_{1\cdots n}\) ,每次询问给出 \(l,r,k\) ,问在 \(s_{l\cdots r}\) 中出现了多少次 \(s_k\) . \(n,q,\su ...
- web项目_学生证管理系统
项目简述: 基于java web实现学生卡管理系统,用户包括学生和学生处,分别实现以下功能. 学生: 1.对本人登录密码的修改 2.申请补办学生卡 3.查看学生卡补办状态 学生处: 1.对学生信息的管 ...
- 利用matlab写一个简单的拉普拉斯变换提取图像边缘
可以证明,最简单的各向同性微分算子是拉普拉斯算子.一个二维图像函数 f(x,y) 的拉普拉斯算子定义为 其中,在 x 方向可近似为 同理,在 y 方向上可近似为 于是 我们得到满足以上三个 ...
- Unity关于方法事件生命周期官方文档
http://docs.unity3d.com/Manual/ExecutionOrder.html 一.组件运行的基本顺序 下图中创建类的顺序为A,B,C,A1,二运行的结果为A1,B,C,A. 可 ...
- 在windows10上安装caffe和tensorflow
最近在Windows10上安装了caffe和tensorflow,折腾了好久.在此记录一下. 安装caffe的过程已在另一篇博客中进行了记录,在此不再赘述.而tensorflow也是非常简单的,也不再 ...
- win2003无线网卡驱动无法安装解决方法
Windows 2003 Server对无线网卡的pci资源分配出了问题,而笔记本bios中屏蔽了pci配置项,无法修改. 打开资源管理器菜单,工具-文件夹选项-显示,去掉“隐藏受保护的操作系统文件” ...
- BugPhobia准备篇章：团队Beta阶段准备工作分析
0x00:序言 To the searching tags, you may well fall in love withhttp://xueba.nlsde.buaa.edu.cn/ 再见,无忧时光 ...