最近把七种排序算法集中在一起写了一遍。
注释里有比较详细的说明。
1 /*排序算法大集合**/
2 #include <stdio.h>
3 #include <string.h>
4 #include <stdlib.h>
5
6 //------------------快速排序------------------//
7 /*
8 核心：
9 如果你知道多少人该站你前面，多少人站你后面，你一定知道你该站哪个位置。
10 算法：
11 1.选取分界数，参考这个分界数，大于参考数放在右边，小于的放在左边。
12 2.对左右两边的序列分别递归进行1处理
13 3.将整个序列合并得到有序结果
14 */
15 //分区函数
16 int Part(int Array[],int left, int right)
17 {
18 int temp;
19 temp = Array[left];//选取第一个数为分界数
20 while(left < right)
21 {
22 while(left < right && Array[right] > temp)
23 {
24 right--;
25 }
26 Array[left] = Array[right];
27 while(left<right && Array[left]<=temp)
28 {
29 left++;
30 }
31 Array[right] = Array[left];
32 }
33 Array[left] = temp;
34 return left;
35 }
36 void Quicksort(int Array[],int left, int right)
37 {
38 if(left < right)
39 {
40 int p= Part(Array, left, right);
41 Quicksort(Array, left, p-1);
42 Quicksort(Array, p+1, right);
43 }
44 }
45 //------------------插入排序------------------//
46 /*
47 核心：
48 每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子序列中的适当位置，直到全部记录插入完成为止。
49 算法：
50 1.初始时，a[0]自成1个有序区，无序区为a[1..n-1]。令i=1
51 2.将a[i]并入当前的有序区a[0…i-1]中形成a[0…i]的有序区间。
52 3. i++并重复第二步直到i==n-1。排序完成。
53 */
54 void InsertSort(int a[], int n)
55 {
56 int i, j, temp;
57 for(i = 1; i < n; ++i)
58 {
59 if(a[i] < a[i - 1])
60 {
61 temp = a[i];
62 for(j = i - 1; j >= 0 && a[j] > temp; --j)
63 a[j + 1] = a[j];
64 a[j + 1] = temp;
65 }
66 }
67 }
68 //------------------选择排序------------------//
69 /*
70 核心：
71 选择排序将数据分为有序区和无序区从无序区选一个最小的元素直接放到有序区的最后。
72 算法：
73 1.初始时，数组全为无序区为a[0..n-1]。令i=0
74 2.在无序区a[i…n-1]中选取一个最小的元素，将其与a[i]交换。交换之后a[0…i]就形成了一个有序区。
75 3.i++并重复第二步直到i==n-1。排序完成。
76 */
77 void SelectionSort(int a[], int n)
78 {
79 int min, i, j;
80 for(i = 0; i < n - 1; ++i)
81 {
82 min = i;
83 for(j = i + 1; j < n; ++j)
84 if(a[j] < a[min])
85 min = j;
86
87 if(min != i)
88 {
89 int t = a[i];
90 a[i] = a[min];
91 a[min] = t;
92 }
93 }
94 }
95
96 //------------------冒泡排序------------------//
97 /*
98 算法：
99 1．比较相邻的前后二个数据，如果前面数据大于后面的数据，就将二个数据交换。
100 2．这样对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就“沉”到数组第N-1个位置。
101 3．N=N-1，如果N不为0就重复前面二步，否则排序完成。
102 分析：
103 冒泡排序毕竟是一种效率低下的排序方法，在数据规模很小时，可以采用。数据规模比较大时，最好用其它排序方法。
104 */
105 void swap(int &a, int &b)
106 {
107 int t = a;
108 a = b;
109 b = t;
110 }
111
112 void BubbleSort(int a[], int n)
113 {
114 int i, j, flag = n;//用flag来记录a[flag]后面的有序数列，便不再比较
115 while(flag > 0)
116 {
117 j = flag;
118 flag = 0;
119 for(i = 0; i < j; ++i)
120 if(a[i] < a[i - 1])
121 {
122 swap(a[i], a[i - 1]);
123 flag = j;
124 }
125 }
126 }
127
128 //------------------堆排序------------------//
129 /*
130 数据结构：
131 堆实际上是一棵完全二叉树，其任何一非叶节点满足性质：
132 任何一非叶节点的关键字不大于或者不小于其左右孩子节点的关键字。
133 堆分为大顶堆和小顶堆，
134 大顶堆的堆顶的关键字肯定是所有关键字中最大的，
135 小顶堆的堆顶的关键字是所有关键字中最小的。
136 算法：
137 1)将初始待排序关键字序列(R1,R2....Rn)构建成大顶堆，此堆为初始的无序区；
138 2)将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,......Rn-1)和新的有序区(Rn),且满足R[1,2...n-1]<=R[n];
139 3)由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,......Rn-1)调整为新堆，
140 然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2....Rn-2)和新的有序区(Rn-1,Rn)。
141 不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。
142 */
143 void HeapAdjust(int a[], int i, int size)//堆的构造
144 {
145 int LeftChild = i * 2;
146 int RightChild = LeftChild + 1;
147 if(i <= size / 2)
148 {
149 int max = i;
150 if(a[LeftChild] > a[max])
151 max = LeftChild;
152 if(RightChild <= size && a[RightChild] > a[max])
153 max = RightChild;
154 if(max != i)
155 {
156 swap(a[i], a[max]);
157 HeapAdjust(a, max, size);
158 }
159 }
160 }
161
162 void HeapSort(int a[], int size)
163 {
164 int i;
165 for(i = size / 2; i >= 1; --i)//堆的初始化
166 HeapAdjust(a, i, size);
167
168 for(i = size; i > 1; --i)
169 {
170 swap(a[1], a[i]);
171 HeapAdjust(a, 1, i - 1);
172 }
173 }
174
175 //------------------归并排序------------------//
176 /*
177 算法：
178 并：
179 将二个有序数列合并，只要从比较二个数列的第一个数，
180 谁小就先取谁，取了后就在对应数列中删除这个数。
181 然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可。
182 将数组分成二组A，B，如果这二组组内的数据都是有序的，那么就可以很方便的将这二组数据进行排序。
183 归：
184 当分出来的小组只有一个数据时，可以认为这个小组组内已经达到了有序，
185 然后再合并相邻的二个小组就可以了。
186 这样通过先递归的分解数列，
187 再合并数列就完成了归并排序。
188 */
189 void MergeArray(int a[], int first, int mid, int last, int temp[])
190 //使a[first...mid]和a[mid+1...last]两部分归并为有序数列
191 {
192 int i = first, j = mid + 1;
193 int m = mid, n = last;
194 int k = 0;
195 while(i <= m && j <= n)
196 {
197 if(a[i] < a[j])
198 temp[k++] = a[i++];
199 else
200 temp[k++] = a[j++];
201 }
202
203 while(i <= m)
204 temp[k++] = a[i++];
205 while(j <= n)
206 temp[k++] = a[j++];
207
208 for(i = 0; i < k; ++i)
209 a[first + i] = temp[i];
210 }
211
212 void mergesort(int a[], int first, int last, int temp[])
213 {
214 if(first < last)
215 {
216 int mid = (first + last) / 2;
217 mergesort(a, first, mid, temp);
218 mergesort(a, mid + 1, last, temp);
219 MergeArray(a, first, mid, last, temp);
220 }
221 }
222
223 bool MergeSort(int a[], int n)
224 {
225 int *p = new int[n];
226 if(p == NULL)
227 return false; //若内存分配失败则返回FALSE
228 mergesort(a, 0, n - 1, p);
229 delete []p;
230 return true;
231 }
232
233 //------------------LSD基数排序------------------//
234 /*
235 算法：
236 1、分配，先从个位开始，根据位值(0-9)分别放到0~9号桶中
237 2、收集，再将放置在0~9号桶中的数据按顺序放到数组中
238 3、重复(1)(2)过程，从个位到最高位
239 */
240 //a[]为常量表，用来取num的第pos位的数字
241 const int a[] = {1, 1, 10, 100, 1000, 10000,
242 100000, 1000000, 10000000, 100000000, 1000000000};
243
244 int GetNumInPos(int num, int pos)//取num的第pos位的数字
245 {
246 return ((num / a[pos]) % 10);
247 }
248
249 int FindMaxDigit(int array[], int size)//找到数组中最大的位数
250 {
251 int cnt = 1, x = 10;
252 for(int i = 0; i < size; ++i)
253 {
254 while(array[i] >= a[cnt + 1])
255 ++cnt;
256 }
257 return cnt;
258 }
259
260 void RadixSort(int array[], int size)
261 {
262 int *radixArrays[10]; //分配0~9的桶子空间
263 int i;
264 int KeyNum = FindMaxDigit(array, size);
265 for(i = 0; i < 10; ++i)
266 {
267 radixArrays[i] = (int *)malloc(sizeof(int) * (size + 1));
268 radixArrays[i][0] = 0; //此处记录各组数据的个数
269 }
270
271 int pos;
272 for(pos = 1; pos <=KeyNum; ++pos)
273 {
274 for(i = 0; i < size; ++i)
275 {
276 int num = GetNumInPos(array[i], pos);
277 int index = ++radixArrays[num][0];
278 radixArrays[num][index] = array[i];
279 }
280 //收集
281 int j;
282 for(i = 0, j = 0; i < 10; ++i)
283 {
284 for(int k = 1; k <= radixArrays[i][0]; ++k)
285 array[j++] = radixArrays[i][k];
286 radixArrays[i][0] = 0;
287 }
288 }
289 for(i = 0; i < 10; ++i)
290 free(radixArrays[i]); //释放分配的空间
291 }
292
293 void PrintArr(int a[], int n)
294 {
295 for(int i = 0; i < n; ++i)
296 printf("%d ", a[i]);
297 printf("\n");
298 }
299
300 int main(void)
301 {
302 int array1[] = {12, 14, 54, 5, 6, 3, 9, 8, 47, 89}, array2[15];
303
304 memcpy(array2, array1, sizeof(array1));
305 int Left = 0, Right = 9;
306 Quicksort(array2, Left, Right);
307 printf("快速排序：\n");
308 PrintArr(array2, 10);
309
310 memcpy(array2, array1, sizeof(array1));
311 InsertSort(array2, 10);
312 printf("插入排序：\n");
313 PrintArr(array2, 10);
314
315 memcpy(array2, array1, sizeof(array1));
316 SelectionSort(array2, 10);
317 printf("选择排序：\n");
318 PrintArr(array2, 10);
319
320 memcpy(array2, array1, sizeof(array1));
321 BubbleSort(array2, 10);
322 printf("冒泡排序：\n");
323 PrintArr(array2, 10);
324
325 //堆排序是从a[1]开始排所以要对数组进行一下调整
326 int i;
327 for(i = 0; i < 10; ++i)
328 array2[i + 1] = array1[i];
329 HeapSort(array2, 10);
330 printf("堆排序：\n");
331 for(i = 0; i < 10; ++i)
332 printf("%d ", array2[i + 1]);
333 printf("\n");
334
335 memcpy(array2, array1, sizeof(array1));
336 MergeSort(array2, 10);
337 printf("归并排序：\n");
338 PrintArr(array2, 10);
339
340 memcpy(array2, array1, sizeof(array1));
341 RadixSort(array2, 10);
342 printf("基数排序：\n");
343 PrintArr(array2, 10);
344
345 return 0;
346 }
七种排序算法的实现和总结
时间： 2024-08-06 11:53:18