转载自:http://www.oschina.net/code/snippet_1434_1721
#include<stdio.h> |
002 | #include<stdlib.h> |
003 | struct node |
004 | { |
005 | int key; |
006 | }r[20]; |
007 | |
008 | struct rnode |
009 | { |
010 | int key; |
011 | int point; |
012 | }; |
013 | |
014 | main() |
015 | { |
016 | void print( struct node a[20], int n); |
017 | int creat(); |
018 | void shell( struct node a[20], int n); |
019 | int hoare( struct node a[20], int l, int h); |
020 | void quick1( struct node a[20], int n); |
021 | void quick2( struct node a[20], int l, int h); |
022 | void heap( struct node a[20], int i, int m); |
023 | void heapsort( struct node a[20], int n); |
024 | void merges( struct node a[20], struct node a2[20], int h1, int mid, int h2); |
025 | void mergepass( struct node a[20], struct node a2[20], int l, int n); |
026 | void mergesort( struct node a[20], int n); |
027 | int yx( int m, int i); |
028 | int radixsort( struct rnode a[20], int n); |
029 | int num,l,h,c; |
030 | struct rnode s[20]; |
031 | c=1; |
032 | while (c!=0) |
033 | { |
034 | printf ( " 主菜单 /n" ); |
035 | printf ( " 1 输入关键字,以-9999表示结束。/n" ); |
036 | printf ( " 2 希尔排序 /n" ); |
037 | printf ( " 3 非递归的快速排序 /n" ); |
038 | printf ( " 4 递归的快速排序 /n" ); |
039 | printf ( " 5 堆排序 /n" ); |
040 | printf ( " 6 归并排序 /n" ); |
041 | printf ( " 7 基数排序 /n" ); |
042 | printf ( " 输入选择 (1--7,0表示结束): " ); |
043 | scanf ( "%d" ,&c); |
044 | switch (c) |
045 | { |
046 | case 1:num=creat();print(r,num); break ; |
047 | case 2:shell(r,num);print(r,num); break ; |
048 | case 3:quick1(r,num);print(r,num); break ; |
049 | case 4:l=0;h=num-1;quick2(r,l,h); |
050 | printf ( "output quick2sort result:/n" ); |
051 | print(r,num); break ; |
052 | case 5:heapsort(r,num); break ; |
053 | case 6:mergesort(r,num);print(r,num); break ; |
054 | case 7:radixsort(s,num); |
055 | } |
056 | } |
057 | } //main end |
058 | |
059 | void print( struct node a[20], int n) |
060 | { |
061 | int i; |
062 | for (i=0;i<n;i++) |
063 | printf ( "%5d" ,a[i ].key); |
064 | printf ( "/n" ); |
065 | } //print end |
066 | |
067 | int creat() |
068 | { |
069 | int i,n; |
070 | n=0; |
071 | printf ( "input keys" ); |
072 | scanf ( "%d" ,&i); |
073 | while (i!=-9999) |
074 | { |
075 | r[n].key=i; |
076 | n++; |
077 | scanf ( "%d" ,&i); |
078 | } |
079 | return (n); |
080 | } //creat end |
081 | |
082 | void shell( struct node a[20], int n) //希尔排序 |
083 | { |
084 | int i,j,k; |
085 | for (i=n;i>=1;i--) |
086 | a[i].key=a[i-1].key; |
087 | k=n/2; |
088 | while (k>=1) |
089 | { |
090 | for (i=k+1;i<=n;i++) |
091 | { |
092 | a[0].key=a[i].key; |
093 | j=i-k; |
094 | while ((a[j].key>a[0].key)&&(j>=0)) |
095 | { |
096 | a[j+k].key=a[j].key; |
097 | j=j-k; |
098 | } |
099 | a[j+k]=a[0]; |
100 | } |
101 | k=k/2; |
102 | } |
103 | for (i=0;i<n;i++) |
104 | a[i].key=a[i+1].key; |
105 | printf ( "输出希尔排序的结果:/n" ); |
106 | } //shell end |
107 | |
108 | 快速排序/// |
109 | |
110 | int hoare( struct node a[20], int l, int h) //分区处理函数 |
111 | { |
112 | int i,j; |
113 | struct node x; |
114 | i=l; |
115 | j=h; |
116 | x.key=a[i].key; |
117 | do |
118 | { |
119 | while ((i<j)&&(a[j].key>=x.key)) |
120 | j--; |
121 | if (i<j) |
122 | { |
123 | a[i].key=a[j].key; |
124 | i++; |
125 | } |
126 | while ((i<j)&&(a[i].key<=x.key)) |
127 | i++; |
128 | if (i<j) |
129 | { |
130 | a[j].key=a[i].key; |
131 | j--; |
132 | } |
133 | } while (i<j); |
134 | a[i].key=x.key; |
135 | return (i); |
136 | } //hoare end |
137 | |
138 | void quick1( struct node a[20], int n) |
139 | { |
140 | int i,l,h,tag,top; |
141 | int s[20][2]; |
142 | l=0;h=n-1;tag=1;top=0; |
143 | do |
144 | { |
145 | while (l<h) |
146 | { |
147 | i=hoare(a,l,h); |
148 | top++; |
149 | s[top][0]=i+1; |
150 | s[top][1]=h; |
151 | h=h-1; |
152 | } |
153 | if (top==0) |
154 | tag=0; |
155 | else |
156 | { |
157 | l=s[top][0]; |
158 | h=s[top][1]; |
159 | top--; |
160 | } |
161 | } while (tag==1); |
162 | printf ( "输出非递归快速排序结果:/n" ); |
163 | } //quick end |
164 | |
165 | void quick2( struct node a[20], int l, int h) //递归的快速排序 |
166 | { |
167 | int i; |
168 | if (l<h) |
169 | { |
170 | i=hoare(a,l,h); |
171 | quick2(a,l,i-1); |
172 | quick2(a,i+1,h); |
173 | } |
174 | } //quick2 end |
175 | |
176 | 快速排序结束 |
177 | |
178 | 堆排序函数// |
179 | |
180 | void heap( struct node a[20], int i, int m) //调整堆的函数 |
181 | { |
182 | struct node x; |
183 | int j; |
184 | x.key=a[i].key; |
185 | j=2*i; |
186 | while (j<=m) |
187 | { |
188 | if (j<m) |
189 | if (a[j].key>a[j+1].key) |
190 | j++; |
191 | if (a[j].key<x.key) |
192 | { |
193 | a[i].key=a[j].key; |
194 | i=j; |
195 | j=2*i; |
196 | } |
197 | else |
198 | j=m+1; |
199 | } |
200 | a[i].key=x.key; |
201 | } //heap end |
202 | |
203 | void heapsort( struct node a[20], int n) //堆排序的主体函数 |
204 | { |
205 | int i,v; |
206 | struct node x; |
207 | for (i=n;i>0;i--) |
208 | a[i].key=a[i-1].key; |
209 | for (i=n/2;i>=1;i--) |
210 | heap(a,i,n); |
211 | printf ( "输出堆排序结果:/n" ); |
212 | for (v=n;v>=2;v--) |
213 | { |
214 | printf ( "%5d" ,a[1].key); |
215 | x.key=a[1].key; |
216 | a[1].key=a[v].key; |
217 | a[v].key=x.key; |
218 | heap(a,1,v-1); |
219 | } |
220 | printf ( "%5d" ,a[1].key); |
221 | for (i=0;i<n;i++) |
222 | a[i].key=a[i+1].key; |
223 | } //heapsort end |
224 | |
225 | /堆排序函数结束/// |
226 | |
227 | //归并函数 |
228 | |
229 | void merges( struct node a[20], struct node a2[20], int h1, int mid, int h2) |
230 | //归并排序的核心算法 |
231 | { |
232 | int i,j,k; |
233 | i=h1;j=mid+1;k=h1-1; |
234 | while ((i<=mid)&&(j<=h2)) |
235 | { |
236 | k=k+1; |
237 | if (a[i].key<=a[j].key) |
238 | { |
239 | a2[k].key=a[i].key; |
240 | i++; |
241 | } |
242 | else |
243 | { |
244 | a2[k].key=a[j].key; |
245 | j++; |
246 | } |
247 | } |
248 | while (i<=mid) |
249 | { |
250 | k++; |
251 | a2[k].key=a[i].key; |
252 | i++; |
253 | } |
254 | while (j<=h2) |
255 | { |
256 | k++; |
257 | a2[k].key=a[j].key; |
258 | i++; |
259 | } |
260 | } //merges end |
261 | |
262 | void mergepass( struct node a[20], struct node a2[20], int l, int n) |
263 | //一趟归并 |
264 | { |
265 | int j,i,h1,mid,h2; |
266 | i=0; |
267 | while ((n-i)>=2*l) |
268 | { |
269 | h1=i; |
270 | mid=h1+l-1; |
271 | h2=i+2*l-1; |
272 | merges(a,a2,h1,mid,h2); |
273 | i=i+2*l; |
274 | } |
275 | if ((n-i)<=l) |
276 | for (j=i;j<=n;j++) |
277 | a2[j].key=a[j].key; |
278 | else |
279 | { |
280 | h1=i; |
281 | mid=h1+l-1; |
282 | h2=n-1; |
283 | merges(a,a2,h1,mid,h2); |
284 | } |
285 | } //mergepass end |
286 | |
287 | void mergesort( struct node a[20], int n) |
288 | { |
289 | int l; |
290 | struct node a2[20]; |
291 | l=1; |
292 | while (l<n) |
293 | { |
294 | mergepass(a,a2,l,n); |
295 | l=2*l; |
296 | mergepass(a2,a,l,n); |
297 | l=2*l; |
298 | } |
299 | printf ( "输出归并排序的结果:/n" ); |
300 | } //mergesort end |
301 | |
302 | ///归并函数结束/// |
303 | |
304 | ///基数排序/// |
305 | |
306 | int yx( int m, int i) //分离关键字倒数第i位有效数字的算法 |
307 | { |
308 | int x; |
309 | switch (i) |
310 | { |
311 | case 1:x=m%10; break ; |
312 | case 2:x=(m%100)/10; break ; |
313 | case 3:x=(m%1000)/100; break ; |
314 | case 4:x=(m%10000)/1000; break ; |
315 | } |
316 | return (x); |
317 | } //yx end |
318 | |
319 | int radixsort( struct rnode a[20], int n) |
320 | { |
321 | int f[11],e[11],i,j,k,l,p,d,t; |
322 | for (i=1;i<=n;i++) |
323 | { |
324 | a[i].key=r[i-1].key; |
325 | a[i].point=i+1; |
326 | } |
327 | a[n].point=0; |
328 | p=1; |
329 | printf ( "输出关键字有效位数 d/n" ); |
330 | scanf ( "%d" ,&d); |
331 | printf ( "输出基数排序的结果:/n" ); |
332 | for (i=1;i<=d;i++) |
333 | { |
334 | for (j=0;j<=10;j++) |
335 | { |
336 | f[j]=0; |
337 | e[j]=0; |
338 | } |
339 | while (p!=0) |
340 | { |
341 | k=yx(a[p].key,i); |
342 | if (f[k]==0) |
343 | { |
344 | f[k]=p; |
345 | e[k]=p; |
346 | } |
347 | else |
348 | { |
349 | l=e[k]; |
350 | a[l].point=p; |
351 | e[k]=p; |
352 | } |
353 | p=a[p].point; |
354 | } |
355 | j=0; |
356 | while (f[j]==0) |
357 | j++; |
358 | p=f[j];t=e[j]; |
359 | while (j<10) |
360 | { |
361 | j++; |
362 | while ((j<10)&&(f[j]==0)) |
363 | j++; |
364 | if (f[j]!=0) |
365 | { |
366 | a[t].point=f[j]; |
367 | t=e[j]; |
368 | } |
369 | } |
370 | a[t].point=0; |
371 | t=p; |
372 | while (t!=0) |
373 | { |
374 | printf ( "%5d" ,a[t].key); |
375 | t=a[t].point; |
376 | } |
377 | printf ( "/n" ); |
378 | } |
379 | return (p); |
380 | } |