1 参考资料：数据结构与算法分析（第三版）（c++）
2 http://blog.csdn.net/theprinceofelf/article/details/6672677
3
4
5
6
7 内排序，均采用数组实现，数组有较多的局限性，这些实现是为了去了解排序算法
8 的操作流程
9
10 #include<iostream>
11 using namespace std;
12
13 void Swap(int &a,int &b);
14 void Print(int *array,int n);
15 void BubbleSort(int *array,int n);
16 void InsertSort(int *array,int n);
17 void ShellSort(int *array,int n);
18 void RadixSort(int *array,int n,int k,int r,int *cnt,int *B);
19 void QuickSort(int Left,int Right,int *array);
20 int FindPos(int Left,int Right);
21 int Parttion(int Left,int Right,int& pos,int *A);
22 void MergeSort(int Left,int Right,int *array,int *B);
23 void ShellSort(int *array,int n);
24 void IssSort(int *array,int n,int temp);
25 void HeapSort(int *array,int n);
26 void HeapAdjust(int *array,int high,int low);
27 int main()
28 {
29 int n=20;
30 int arry[n]={12,45,78,2,3,45,12,47,36,5,112,1178,14,20,10,58,74,65,24,17};
31 //这两个数组主要是在用数组实现基数排序过程中要使用到
32 int cnt[n];
33 int B[n];
34
35 printf("要进行排序的数组为：\n");
36 Print(arry,n);
37
38
39 printf("冒泡排序：\n");
40 BubbleSort(arry,n);
41 Print(arry,n);
42 printf("插入排序：\n");
43 InsertSort(arry,n);
44 Print(arry,n);
45 printf("基数排序：\n");
46 RadixSort(arry,n,4,10,cnt,B);
47 Print(arry,n);
48 printf("快速排序：\n");
49 QuickSort(0,n-1,arry);
50 Print(arry,n);
51 printf("归并排序：\n");
52 MergeSort(0,n-1,arry,B);
53 Print(arry,n);
54 printf("希尔排序：\n");
55 ShellSort(arry,n);
56 Print(arry,n);
57 printf("堆排序：\n");
58 HeapSort(arry,n);
59 Print(arry,n);
60 return 0;
61 }
62
63
64
65 void Swap(int &a,int &b)
66 {
67 int temp=a;
68 a=b;
69 b=temp;
70 }
71
72 void Print(int *array,int n)
73 {
74
75 for(int i=0;i<n;i++)
76 {
77 printf("%d\t",array[i]);
78 }
79 printf("\n\n");
80 }
81
82 //冒泡排序的时间复杂度为n^2，稳定
83 void BubbleSort(int *array,int n)
84 {
85 for(int i=0;i<n;i++)
86 {
87 //for(int j=n-i;j>0;j--) //这个是从最后一位开始进行冒泡排序，比较直观
88 for(int j=0;j<n-1-i;j++)
89 {
90 if(array[j]>array[j+1])
91 {
92 Swap(array[j],array[j+1]);
93 }
94 }
95 }
96 }
97
98 //插入排序的实现
99 void InsertSort(int *array,int n)
100 {
101 for(int i=1;i<n;i++)
102 {
103 for(int j=i;j>0;j--)
104 {
105 if(array[j]<array[j-1])
106 {
107 Swap(array[j],array[j-1]);
108 }
109 }
110 }
111 }
112
113
114
115 //基数排序的数组实现的过程
116 /*参数的意义：三个数组为交换过程中的使用，标记位置过程的使用，原数组
117 K为要进行排序的数组中数字的最大位数，r为进制*/
118 void RadixSort(int *array,int n,int k,int r,int *cnt,int *B)
119 {
120 int j;
121
122 for(int i=0,rtoi=1;i<k;i++,rtoi*=r)
123 {
124 for(j=0;j<r;j++)
125 {
126 cnt[j]=0;
127 }
128 for(j=0;j<n;j++)
129 {
130 cnt[(array[j]/rtoi)%r]++;
131 }
132 for(j=1;j<r;j++)
133 {
134 cnt[j]=cnt[j]+cnt[j-1];
135 }
136 for(j=n-1;j>=0;j--)
137 {
138 //式子中所要表达的就是进行取余，从最低位开始进行
139 B[--cnt[(array[j]/rtoi)%r]]=array[j];
140 }
141 for(j=0;j<n;j++)
142 {
143 array[j]=B[j];
144 }
145 }
146 }
147
148
149
150 //快速排序实现，选择轴值在中间，但是在极端情况下，轴值在首位或者末尾均可
151 //快速排序的优化有许多的方式，可以用堆栈代替递归，子数组在排序时长度的选择均可以进行优化
152 void QuickSort(int Left,int Right,int *A)
153 {
154 if (Left >= Right)
155 {
156 return;
157 }
158 //将轴值放在数组的最后
159 int pos = FindPos(Left, Right);
160 Swap(pos, Right);
161 // Left-1这个位置在数组的下界之前，目的是为了防止溢出
162 int k = Parttion(Left - 1, Right, A[Right],A);
163 Swap(k, Right);
164 QuickSort(Left, k - 1,A);
165 QuickSort(k + 1, Right,A);
166 }
167
168
169 int FindPos(int Left, int Right)
170 {
171 return (Left + Right) /2;
172 }
173
174
175 int Parttion(int Left, int Right, int& pos,int *A)
176 {
177 int i = Left;
178 int j = Right;
179 do
180 {
181 while ((pos>=A[Left])&&(Left<Right))
182 {
183 Left++;
184 }
185 //此处Left<Right保证了当轴值为子数组的最小值（即分隔出来以后左半部分的长度为0）不会越界
186 while ((Left < Right) && (pos <=A[Right]))
187 {
188 Right--;
189 }
190 Swap(Left, Right);
191 } while (Left < Right);
192 return Left;
193 }
194
195
196
197 //归并排序的实现：
198 void MergeSort(int Left,int Right,int *array,int *B)
199 {
200 if(Left==Right)
201 {
202 return;
203 }
204 int mid=(Left+Right)/2;
205 MergeSort(Left,mid,array,B);
206 MergeSort(mid+1,Right,array,B);
207 //复制到数组B中进行操作
208 for(int i=Left;i<=Right;i++)
209 {
210 B[i]=array[i];
211 }
212
213 int i=Left,j=mid+1;
214 for(int k=Left;k<=Right;k++)
215 {
216 //左侧数组是否已经用完
217 if(i==mid+1)
218 {
219 array[k]=B[j++];
220 }
221 //右侧数据是否用完
222 else if(j>Right)
223 {
224 array[k]=B[i++];
225 }
226 //均未用完，则需要进行比较归位
227 else if(B[i]<B[j])
228 {
229 array[k]=B[i++];
230 }
231 else
232 {
233 array[k]=B[j++];
234 }
235 }
236 }
237
238
239 //希尔排序的实现
240 //希尔排序的最后一轮处理其实就是插入排序
241 void ShellSort(int *array,int n)
242 {
243 for(int i=n/2;i>2;i/=2)
244 {
245 for(int j=0;j<i;j++)
246 {
247 IssSort(&array[j],n-j,i);
248 }
249 //最后一次处理为插入排序。所以增量为1
250 IssSort(array,n,1);
251 }
252 }
253
254
255
256 void IssSort(int *array,int n,int temp)
257 {
258 for(int i=temp;i<n;i+=temp)
259 {
260 for(int j=i;(j>=temp)&&(array[j]<array[j-temp]);j-=temp)
261 {
262 Swap(array[j],array[j-temp]);
263 }
264 }
265 }
266
267
268
269
270 //堆排序的实现
271 void HeapSort(int *array,int n)
272 {
273 for(int i=n/2-1;i>=0;--i)
274 {
275 HeapAdjust(array,i,n-1);
276 }
277 for(int i=n-1;i>0;--i)
278 {
279 Swap(array[0],array[i]);
280 HeapAdjust(array,0,i-1);
281 }
282 }
283
284
285
286 void HeapAdjust(int *array,int low,int high)
287 {
288 int temp=array[low];
289 for(int i=low*2+1;i<=high;i*=2)
290 {
291 if(i<high&&array[i]<=array[i+1])
292 {
293 ++i;
294 }
295 if(array[i]<=temp)
296 {
297 break;
298 }
299 array[low]=array[i];
300 low=i;
301 }
302 array[low]=temp;
303 }
时间： 2024-10-17 09:45:45