1 /************************************************************************/
2 /* 八大排序算法概述及实现 */
3 /* */
4 /* |- 冒泡排序 */
5 /* - 交换排序 -| */
6 /* | |- 快速排序 */
7 /* | */
8 /* | |- 插入排序 */
9 /* | 插入排序 -| */
10 /* | |- 希尔排序 */
11 /* 排序算法 -| */
12 /* | |- 选择排序 */
13 /* | 选择排序 -| */
14 /* | |- 堆排序 */
15 /* | */
16 /* | 归并排序 */
17 /* | */
18 /* - 基数排序 */
19 /* */
20 /*************************************************************************/
21
22 #include <iostream>
23 #include <cstring>
24 using namespace std;
25
26 /************************************************************************/
27 /* 冒泡排序 */
28 /************************************************************************/
29 void bubbleSort(int* arr, int len)
30 {
31 int temp = 0;
32 for (int i = 0; i < len - 1; i++) //排序len-1次
33 {
34 for (int j = 0; j < len - i - 1; j++) //每次找到当前范围内的最大值
35 {
36 if (arr[j] > arr[j + 1])
37 {
38 temp = arr[j];
39 arr[j] = arr[j + 1];
40 arr[j + 1] = temp;
41 }
42 }
43 }
44 }
45
46 /************************************************************************/
47 /* 快速排序 */
48 /************************************************************************/
49 void quikSort(int* arr, int left, int right)
50 {
51 if (left < right)
52 {
53 int i = left, j = right, x = arr[i];
54 while (i < j)
55 {
56 while (i < j&&x <= arr[j])
57 j--;
58 if (i < j)
59 arr[i++] = arr[j];
60
61 while (i < j&&x >= arr[i])
62 i++;
63 if (i < j)
64 arr[j--] = arr[i];
65 }
66 arr[i] = x;
67 quikSort(arr, 0, i - 1);
68 quikSort(arr, i + 1, right);
69 }
70 }
71
72 /************************************************************************/
73 /* 插入排序 */
74 /************************************************************************/
75 void insertSort(int* arr, int len)
76 {
77 int temp;
78 for (int i = 1; i < len; i++) //从第2个数开始
79 {
80 for (int j = i - 1; j >= 0; j--)
81 {
82 if (arr[j] > arr[j + 1])
83 {
84 temp = arr[j];
85 arr[j] = arr[j + 1];
86 arr[j + 1] = temp;
87 }
88 }
89 }
90 }
91
92 /************************************************************************/
93 /* 希尔排序 */
94 /************************************************************************/
95 void shellSort(int* arr, int len)
96 {
97 int d = len / 2, temp;
98 while (d >= 1)
99 {
100 for (int i = d; i < len; i++)
101 {
102 for (int j = i - d; j >= 0; j -= d)
103 {
104 if (arr[j] > arr[j + d])
105 {
106 temp = arr[j];
107 arr[j + d] = arr[j];
108 arr[j] = temp;
109 }
110 }
111 }
112 d /= 2;
113 }
114 }
115
116 /************************************************************************/
117 /* 选择排序 */
118 /************************************************************************/
119 void selectSort(int* arr, int len)
120 {
121 int id, temp;
122 for (int i = 0; i < len - 1; i++) //进行len-1次选择
123 {
124 id = 0;
125 for (int j = 0; j < len - i; j++) //找到最大数据的位置
126 if (arr[j] > arr[id])
127 id = j;
128
129 temp = arr[id];
130 arr[id] = arr[len - i - 1];
131 arr[len - i - 1] = temp;
132 }
133 }
134
135 /************************************************************************/
136 /* 堆排序 */
137 /************************************************************************/
138 //调整结点
139 void adjustNode(int* arr, int len, int n)
140 {
141 int l, r, max, temp;
142 l = 2 * n + 1;
143 r = 2 * n + 2;
144 max = n;
145
146 if (l < len&&arr[n] < arr[l])
147 max = l;
148 if (r < len&&arr[n] < arr[r])
149 max = r;
150
151 if (max != n)
152 {
153 temp = arr[n];
154 arr[n] = arr[max];
155 arr[max] = temp;
156
157 adjustNode(arr, len, max);
158 }
159 }
160
161 //建立堆
162 void makeHeap(int* arr, int len)
163 {
164 for (int i = len / 2; i >= 0; i--)
165 adjustNode(arr, len, i);
166 }
167
168 //堆排序
169 void heapSort(int* arr, int len)
170 {
171 makeHeap(arr, len);
172
173 int temp;
174 for (int i = len - 1; i >= 0; i--)
175 {
176 temp = arr[i];
177 arr[i] = arr[0];
178 arr[0] = temp;
179
180 adjustNode(arr, i, 0);
181 }
182 }
183
184 /************************************************************************/
185 /* 归并排序 */
186 /************************************************************************/
187 //将数组中的两个局部有序序列合并（temp数组中的内存足够）
188 void mergeArray(int* arr, int first, int mid, int last, int temp[])
189 {
190 int i = first, j = mid + 1;
191 int m = mid, n = last;
192 int k = 0;
193
194 while (i <= m && j <= n)
195 {
196 if (arr[i] <= arr[j])
197 temp[k++] = arr[i++];
198 else
199 temp[k++] = arr[j++];
200 }
201
202 while (i <= m)
203 temp[k++] = arr[i++];
204
205 while (j <= n)
206 temp[k++] = arr[j++];
207
208 for (i = 0; i < k; i++)
209 arr[first + i] = temp[i];
210 }
211
212 //归并排序
213 void mergeSort(int* arr, int first, int last, int temp[])
214 {
215 if (first < last)
216 {
217 int mid = (first + last) >> 1;
218 mergeSort(arr, first, mid, temp);
219 mergeSort(arr, mid + 1, last, temp);
220 mergeArray(arr, first, mid, last, temp);
221 }
222 }
223
224 /************************************************************************/
225 /* 基数排序 */
226 /************************************************************************/
227 //计算数组中所有数据的最大位数
228 int maxbit(int data[], int n)
229 {
230 int d = 1;
231 for (int i = 0; i < n; i++)
232 {
233 int c = 1;
234 int p = data[i];
235 while (p / 10)
236 {
237 p = p / 10;
238 c++;
239 }
240 if (c > d)
241 d = c;
242 }
243 return d;
244 }
245
246 //基数排序
247 void radixSort(int arr[], int n)
248 {
249 int* tmp = new int[10];
250 int* count = new int[10];
251
252 int d = maxbit(arr, n);
253 int r = 1;
254 for (int i = 0; i < d; i++)
255 {
256
257 for (int i = 0; i < 10; i++)//装桶之前要先清桶
258 count[i] = 0;
259 for (i = 0; i < n; i++) //记录每个桶的记录数
260 {
261 int k = arr[i] / r;
262 int q = k % 10;
263 count[q]++;
264 }
265 for (i = 1; i < 10; i++)//计算位置
266 {
267 count[i] += count[i - 1];
268 }
269 for (int j = n - 1; j >= 0; j--) //将排序后的结果存到tmp中
270 {
271 int p = arr[j] / r;
272 int s = p % 10;
273 tmp[count[s] - 1] = arr[j];
274 count[s]--;
275 }
276 for (i = 0; i < n; i++)
277 {
278 arr[i] = tmp[i];
279 }
280 r = r * 10;
281 }
282
283 delete[] tmp;
284 delete[] count;
285 }
286
287 //打印数组
288 void printArr(int* arr, int len)
289 {
290 for (int i = 0; i < len; i++)
291 {
292 cout << arr[i] << ' ';
293 }
294 cout << endl;
295 }
296
297 int main()
298 {
299 int num, temp;
300
301 cout << "请输入待排序的序列（格式：序列长度n 数1 数2 ... 数n），以回车符结束输入：" << endl;
302 cin >> num;
303 int* parr = new int[num];
304 int* parr0 = new int[num];
305 int* ptemp = new int[num]; //辅助内存
306 for (int i = 0; i < num; i++)
307 {
308 cin >> temp;
309 parr[i] = temp;
310 }
311 memcpy(parr0, parr, sizeof(int)*num);
312
313 cout << "\n请选择排序方法：\n";
314 cout << "0 原数组序列； 1 冒泡排序； 2 快速排序； 3 插入排序； 4 希尔排序；\n";
315 cout << "5 选择排序； 6 堆排序； 7 归并排序； 8 基数排序; 非数字结束！\n";
316 int id;
317 while (cin >> id)
318 {
319 switch (id)
320 {
321 case 0:
322 memcpy(parr, parr0, sizeof(int)*num);
323 break;
324 case 1:
325 memcpy(parr, parr0, sizeof(int)*num);
326 bubbleSort(parr, num);
327 break;
328 case 2:
329 memcpy(parr, parr0, sizeof(int)*num);
330 quikSort(parr, 0, num - 1);
331 break;
332 case 3:
333 memcpy(parr, parr0, sizeof(int)*num);
334 insertSort(parr, num);
335 break;
336 case 4:
337 memcpy(parr, parr0, sizeof(int)*num);
338 shellSort(parr, num);
339 break;
340 case 5:
341 memcpy(parr, parr0, sizeof(int)*num);
342 selectSort(parr, num);
343 break;
344 case 6:
345 memcpy(parr, parr0, sizeof(int)*num);
346 heapSort(parr, num);
347 break;
348 case 7:
349 memcpy(parr, parr0, sizeof(int)*num);
350 mergeSort(parr, 0, num - 1, ptemp);
351 break;
352 case 8:
353 memcpy(parr, parr0, sizeof(int)*num);
354 radixSort(parr, num);
355 break;
356 default:
357 break;
358 }
359 printArr(parr, num);
360
361 cout << "\n请选择排序方法：";
362 }
363
364 printArr(parr, num);
365
366 delete[] parr;
367 delete[] parr0;
368 delete[] ptemp;
369 }
