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);
}

273

//****************************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];

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

附件列表

排序.jpg

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温故而知新-冒泡法排序
冒泡法排序是各种初学者在学习数组与循环结构时都会练习的一种简单排序算法. 冒泡法的精髓在于比较相邻的两个元素,较大的元素会不断的排到队伍后面去,就像水里的泡泡一样不断向上跑. 想像一下倒在一个透明玻璃 ...

随机推荐

mfc Edit控件属性
设置Edit控件属性窗口创建顺序初始化Edit控件数据一.设置Edit控件属性 .Align Text :Right 二.窗口创建顺序 CMywindowdlg: 窗口构造函数 OnCreate ...
项目 - RM 部署上centos7 之后出现的一些问题和解决方法
系统版本: [root@localhost logs]# cat /etc/redhat-release CentOS Linux release (Core) 获取方法来自:https://www. ...
使用Redis做分布式
一为什么使用 Redis 在项目中使用 Redis,主要考虑两个角度:性能和并发.如果只是为了分布式锁这些其他功能,还有其他中间件 Zookpeer 等代替,并非一定要使用 Redis. 性能: 如 ...
JS基础内容小结（基础）（一）
字符串的各类方法 str.charAt(1); 从第0个开始计算获取第一个子符串,如str=‘你好吗’获取到‘好’ str.charCodeAt(1); 获取对应字符串的编码数字:从第0个开始计算 S ...
Android几行代码实现监听微信聊天
原创作品,转载请注明出处,尊重别人的劳动果实. 2017.2.7更新: *现在适配微信版本更加容易了,只需要替换一个Recourse-ID即可 *可以知道对方发的是小视频还是语音,并获取秒数. *可以 ...
ASP.NetCore2.0概览
微软为了统一微软平台,造就了.netStandard,不管之前的Framework还是最新的.netCore都必须支持.netStandard标准来统一各个平台的开发api. 以下是之前的微软各个 ...
软件测试_APP测试_兼容性测试
APP的兼容测试主要就是测试APP的安装.启动.运行.卸载测试,以及安装时间 .启动时间.CPU占用.内存占用.流量耗用.电量耗用等性能上的测试. 兼容性测试点: 一.内部兼容性: 1.与本地和其他主 ...
Daily Scrum NO.2
工作概况符美潇(PM) 昨日完成的工作 1.Daily Scrum.日常会议及日常工作的分配和查收. 2.为两名团队新成员制定了任务并录入TFS. 今日工作 1.Daily Scrum.日常会议及日 ...
linux内核分析--计算机是如何工作的
实验部分使用gcc -S -o main.s main.c -m32命令将源代码编译成汇编代码. 源代码如下: int g(int x) { return x + 9; } int f(int x) ...
Linux内核分析——第八周学习笔记
实验作业:进程调度时机跟踪分析进程调度与进程切换的过程 20135313吴子怡.北京电子科技学院 [第一部分]理解Linux系统中进程调度的时机 1.Linux的调度程序是一个叫schedule()的 ...

Chapter 9 (排序)

附件列表

Chapter 9 (排序)的更多相关文章

随机推荐

热门专题