Chapter 9 (排序)

Posted lyndonmario

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了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("
");
}

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("
");
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——堆排序

超级有用的9个PHP代码片段

VSCode自定义代码片段9——JS中的面向对象编程

python进阶学习chapter02（列表字典集合操作）

BCZM: Chapter 2

chapter1.高通量序列实验简介：设计与生物信息学分析