各种排序(你懂的?)

raotf

1. #include <stdio.h>
   
2. #include <conio.h>
   
3. #include <Windows.h>
   
4. #include <time.h>
   
5. 
   
6. #define MAX 12345
   
7. 
   
8. void data_shuchu(int* p,int leng);
   
9. void data_fuzhi(int* p,int* data,int leng);
   
10. void paixu_maopao(int* p,int leng);
    
11. void paixu_xuanze(int* p,int leng);
    
12. void paixu_charu(int* p,int leng);
    
13. void paixu_kuaisu(int* p,int tou,int wei);
    
14. int* paixu_guibing(int* p,int leng);
    
15. int* guibing_hebing(int* zuo_data,int zuo_leng,int* you_data,int you_leng);
    
16. int kuaisu_dingwei(int* p,int tou,int wei);
    
17. double pk_paixu(int* p,int leng,char* paixu);
    
18. 
    
19. 
    
20. void main()
    
21. {
    
22. 
    
23. int data[MAX];
    
24. int p[MAX];
    
25. int i;
    
26. double yongshi;
    
27. double paixu_time[5]={0};
    
28. char* paixu_str[]={"插入排序","快速排序","归并排序","冒泡排序","选择排序"};
    
29. 
    
30. srand(time(0));
    
31. for(i=0;i<MAX;i++)
    
32. data[i]=rand();
    
33. 
    
34. for(i=0;i<10*5;i++)
    
35. {
    
36. if(0==i%5)
    
37. printf("第%d轮:\n",i/5+1);
    
38. 
    
39. data_fuzhi(p,data,MAX);
    
40. //data_shuchu(p,MAX);
    
41. yongshi=pk_paixu(p,MAX,paixu_str[i%5]);
    
42. //data_shuchu(p,MAX);
    
43. paixu_time[i%5]+=yongshi;
    
44. printf("%s排序用时: %lf秒\n",paixu_str[i%5],yongshi);
    
45. if(4==i%5)
    
46. printf("\n");
    
47. }
    
48. 
    
49. for(int j=0;j<5;j++)
    
50. printf("%s平均用时: %lf秒\n",paixu_str[j],paixu_time[j]/(i/5));
    
51. 
    
52. getch();
    
53. return;
    
54. }
    
55. 
    
56. 
    
57. double pk_paixu(int* p,int leng,char* paixu)
    
58. {
    
59. int* data;
    
60. double t_avg;
    
61. LONGLONG t1_long;
    
62. LONGLONG t2_long;
    
63. LARGE_INTEGER litmp;
    
64. 
    
65. QueryPerformanceFrequency(&litmp);
    
66. t_avg=litmp.QuadPart;
    
67. 
    
68. QueryPerformanceCounter(&litmp);
    
69. t1_long=litmp.QuadPart;
    
70. 
    
71. if(!strcmp(paixu,"归并排序"))
    
72. {
    
73. data=paixu_guibing(p,leng);
    
74. }
    
75. else if(!strcmp(paixu,"冒泡排序"))
    
76. {
    
77. paixu_maopao(p,leng);
    
78. }
    
79. else if(!strcmp(paixu,"选择排序"))
    
80. {
    
81. paixu_xuanze(p,leng);
    
82. }
    
83. else if(!strcmp(paixu,"插入排序"))
    
84. {
    
85. paixu_charu(p,leng);
    
86. }
    
87. else if(!strcmp(paixu,"快速排序"))
    
88. {
    
89. paixu_kuaisu(p,0,leng-1);
    
90. }
    
91. 
    
92. QueryPerformanceCounter(&litmp);
    
93. t2_long=litmp.QuadPart;
    
94. 
    
95. 
    
96. if(!strcmp(paixu,"归并排序"))
    
97. data_fuzhi(p,data,leng);
    
98. 
    
99. return (t2_long-t1_long)/t_avg;
    
100. }
     
101. 
     
102. void data_shuchu(int* p,int leng)
     
103. {
     
104. for(int i=0;i<leng;i++)
     
105. {
     
106. if(i%10==0)
     
107. printf("\n");
     
108. printf("%d ",p[i]);
     
109. }
     
110. printf("\n");
     
111. return;
     
112. }
     
113. 
     
114. void data_fuzhi(int*p,int* data,int leng)
     
115. {
     
116. for(int i=0;i<leng;i++)
     
117. *(p+i)=*(data+i);
     
118. return;
     
119. }
     
120. 
     
121. int* paixu_guibing(int* p,int leng)
     
122. {
     
123. if(leng<=1)
     
124. return p;
     
125. 
     
126. int zuo_leng=leng/2;
     
127. int you_leng=leng-zuo_leng;
     
128. int* zuo_data=new int[zuo_leng];
     
129. int* you_data=new int[you_leng];
     
130. 
     
131. for(int i=0;i<zuo_leng;i++)
     
132. {
     
133. *(zuo_data+i)=*(p+i);
     
134. *(you_data+i)=*(p+i+zuo_leng);
     
135. }
     
136. if(0!=leng/2)
     
137. *(you_data+you_leng-1)=*(p+leng-1);
     
138. 
     
139. zuo_data=paixu_guibing(zuo_data,zuo_leng);
     
140. you_data=paixu_guibing(you_data,you_leng);
     
141. return guibing_hebing(zuo_data,zuo_leng,you_data,you_leng);
     
142. }
     
143. 
     
144. int* guibing_hebing(int* zuo_data,int zuo_leng,int* you_data,int you_leng)
     
145. {
     
146. int* data=new int[zuo_leng+you_leng];
     
147. 
     
148. int zuo=0;
     
149. int you=0;
     
150. 
     
151. while(zuo<zuo_leng&&you<you_leng)
     
152. {
     
153. if(*(zuo_data+zuo)<=*(you_data+you))
     
154. {
     
155. *(data+zuo+you)=*(zuo_data+zuo);
     
156. zuo++;
     
157. }
     
158. else
     
159. {
     
160. *(data+zuo+you)=*(you_data+you);
     
161. you++;
     
162. }
     
163. }
     
164. while(zuo<zuo_leng)
     
165. data[zuo+you]=zuo_data[zuo++];
     
166. while(you<you_leng)
     
167. data[zuo+you]=you_data[you++];
     
168. 
     
169. return data;
     
170. }
     
171. 
     
172. void paixu_kuaisu(int *p,int tou,int wei)
     
173. {
     
174. if(tou<wei)
     
175. {
     
176. int index=kuaisu_dingwei(p,tou,wei);
     
177. paixu_kuaisu(p,tou,index-1);
     
178. paixu_kuaisu(p,index+1,wei);
     
179. }
     
180. return;
     
181. }
     
182. 
     
183. int kuaisu_dingwei(int *p,int tou,int wei)
     
184. {
     
185. int data=p[tou+(wei-tou)/2];
     
186. p[tou+(wei-tou)/2]=p[tou];
     
187. 
     
188. while(tou<wei)
     
189. {
     
190. while(tou<wei&&*(p+wei)>=data)
     
191. wei--;
     
192. *(p+tou)=*(p+wei);
     
193. 
     
194. while(tou<wei&&*(p+tou)<=data)
     
195. tou++;
     
196. *(p+wei)=*(p+tou);
     
197. 
     
198. }
     
199. *(p+tou)=data;
     
200. return tou;
     
201. }
     
202. 
     
203. void paixu_maopao(int* p,int leng)
     
204. {
     
205. int data;
     
206. for(int i=0;i<leng-1;i++)
     
207. {
     
208. for(int j=leng-1;j>i;j--)
     
209. {
     
210. if(*(p+j)<*(p+j-1))
     
211. {
     
212. data=*(p+j);
     
213. *(p+j)=*(p+j-1);
     
214. *(p+j-1)=data;
     
215. }
     
216. }
     
217. }
     
218. return;
     
219. }
     
220. 
     
221. void paixu_xuanze(int* p,int leng)
     
222. {
     
223. int data;
     
224. for(int i=0;i<leng-1;i++)
     
225. {
     
226. for(int j=i;j<leng;j++)
     
227. {
     
228. if(*(p+i)>*(p+j))
     
229. {
     
230. data=*(p+i);
     
231. *(p+i)=*(p+j);
     
232. *(p+j)=data;
     
233. }
     
234. }
     
235. }
     
236. return;
     
237. }
     
238. 
     
239. void paixu_charu(int *p,int leng)
     
240. {
     
241. int data;
     
242. int index;
     
243. for(int i=1;i<leng;i++)
     
244. {
     
245. data=*(p+i);
     
246. index=i;
     
247. while(index>0&&*(p+index-1)>data)
     
248. {
     
249. *(p+index)=*(p+index-1);
     
250. index--;
     
251. }
     
252. *(p+index)=data;
     
253. }
     
254. 
     
255. return;
     
256. }

复制代码

下面是更新版~~~~~

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <conio.h>
   
4. #include <string.h>
   
5. #include <Windows.h>
   
6. #include <time.h>
   
7. 
   
8. #define MAX 123456
   
9. #define PAIXU_CHARU 0
   
10. #define PAIXU_KUAISU 1
    
11. #define PAIXU_GUIBING 2
    
12. #define PAIXU_MAOPAO 3
    
13. #define PAIXU_XUANZE 4
    
14. #define PAIXU_XIER 5
    
15. #define PAIXU_YIERSAN 6
    
16. #define PAIXU_GESHIBAI 7
    
17. #define PAIXU_DUI 8
    
18. #define PAIXU_QSORT 9
    
19. 
    
20. #define FANGFASHU 10
    
21. 
    
22. 
    
23. void data_shuchu(int* p,int leng);
    
24. void data_fuzhi(int* p,int* data,int leng);
    
25. void paixu_maopao(int* p,int leng,int (* cmp)(const void* a,const void* b));
    
26. void paixu_xuanze(int* p,int leng,int (* cmp)(const void* a,const void* b));
    
27. void paixu_charu(int* p,int leng,int (* cmp)(const void* a,const void* b));
    
28. void paixu_kuaisu(int* p,int leng,int (* cmp)(const void* a,const void* b));
    
29. void paixu_xier(int* p,int leng,int (* cmp)(const void* a,const void* b));
    
30. void paixu_geshibai(int* p,int leng,int (* cmp)(const void* a,const void* b));
    
31. void paixu_dui(int* p,int leng,int (* cmp)(const void* a,const void* b));
    
32. int paixu_fangfa(const void* a,const void* b);
    
33. int* paixu_guibing(int* p,int leng,int (* cmp)(const void* a,const void* b));
    
34. int* paixu_yiersan(int* p,int leng,int (* cmp)(const void* a,const void* b));
    
35. int* guibing_hebing(int* zuo_data,int zuo_leng,int* you_data,int you_leng,int (* cmp)(const void* a,const void* b));
    
36. int kuaisu_dingwei(int* p,int tou,int wei,int (* cmp)(const void* a,const void* b));
    
37. void dui_jian(int* p,int s,int leng,int (* cmp)(const void* a,const void* b));
    
38. double pk_paixu(int* p,int leng,int style,int (* cmp)(const void* a,const void* b));
    
39. 
    
40. 
    
41. void main()
    
42. {
    
43. 
    
44. int* data=new int[MAX];
    
45. int* p=new int[MAX];
    
46. int i;
    
47. double yongshi;
    
48. double paixu_time[FANGFASHU]={0};
    
49. char* paixu_str[FANGFASHU]={"插入排序","快速排序","归并排序","冒泡排序","选择排序","希尔排序","计数排序","基数排序","堆排序 ","QSORT "};
    
50. 
    
51. srand(time(0));
    
52. for(i=0;i<MAX;i++)
    
53. data[i]=rand();
    
54. 
    
55. for(i=0;i<3*FANGFASHU;i++)
    
56. {
    
57. if(0==i%FANGFASHU)
    
58. printf("第%d轮:\n",i/FANGFASHU+1);
    
59. 
    
60. data_fuzhi(p,data,MAX);
    
61. //data_shuchu(p,MAX);
    
62. yongshi=pk_paixu(p,MAX,i%FANGFASHU,paixu_fangfa);
    
63. //data_shuchu(p,MAX);
    
64. paixu_time[i%FANGFASHU]+=yongshi;
    
65. 
    
66. printf("%s排序用时: %lf\n",paixu_str[i%FANGFASHU],yongshi);
    
67. 
    
68. if(FANGFASHU-1==i%FANGFASHU)
    
69. printf("\n");
    
70. }
    
71. 
    
72. for(int j=0;j<FANGFASHU;j++)
    
73. printf("%s平均用时: %lf\n",paixu_str[j],paixu_time[j]/(i/FANGFASHU));
    
74. 
    
75. getch();
    
76. return;
    
77. }
    
78. 
    
79. 
    
80. double pk_paixu(int* p,int leng,int style,int (* cmp)(const void* a,const void* b))
    
81. {
    
82. int* data;
    
83. double t_avg;
    
84. LONGLONG t1_long;
    
85. LONGLONG t2_long;
    
86. LARGE_INTEGER litmp;
    
87. 
    
88. QueryPerformanceFrequency(&litmp);
    
89. t_avg=litmp.QuadPart;
    
90. 
    
91. QueryPerformanceCounter(&litmp);
    
92. t1_long=litmp.QuadPart;
    
93. 
    
94. switch(style)
    
95. {
    
96. case PAIXU_CHARU:
    
97. //paixu_charu(p,leng,cmp);
    
98. break;
    
99. 
    
100. case PAIXU_KUAISU:
     
101. paixu_kuaisu(p,leng,cmp);
     
102. break;
     
103. 
     
104. case PAIXU_GUIBING:
     
105. data=paixu_guibing(p,leng,cmp);
     
106. break;
     
107. 
     
108. case PAIXU_MAOPAO:
     
109. //paixu_maopao(p,leng,cmp);
     
110. break;
     
111. 
     
112. case PAIXU_XUANZE:
     
113. //paixu_xuanze(p,leng,cmp);
     
114. break;
     
115. 
     
116. case PAIXU_XIER:
     
117. paixu_xier(p,leng,cmp);
     
118. 
     
119. case PAIXU_YIERSAN:
     
120. data=paixu_yiersan(p,leng,cmp);
     
121. break;
     
122. 
     
123. case PAIXU_GESHIBAI:
     
124. paixu_geshibai(p,leng,cmp);
     
125. break;
     
126. 
     
127. case PAIXU_DUI:
     
128. paixu_dui(p,leng,cmp);
     
129. break;
     
130. 
     
131. case PAIXU_QSORT:
     
132. qsort(p,leng,sizeof(int),cmp);
     
133. break;
     
134. 
     
135. default:break;
     
136. }
     
137. 
     
138. QueryPerformanceCounter(&litmp);
     
139. t2_long=litmp.QuadPart;
     
140. 
     
141. 
     
142. if(PAIXU_GUIBING==style||PAIXU_YIERSAN==style)
     
143. data_fuzhi(p,data,leng);
     
144. 
     
145. return (t2_long-t1_long)/t_avg;
     
146. }
     
147. 
     
148. void data_shuchu(int* p,int leng)
     
149. {
     
150. for(int i=0;i<leng;i++)
     
151. {
     
152. if(i%10==0)
     
153. printf("\n");
     
154. printf("%d ",p[i]);
     
155. }
     
156. printf("\n");
     
157. return;
     
158. }
     
159. 
     
160. void data_fuzhi(int*p,int* data,int leng)
     
161. {
     
162. for(int i=0;i<leng;i++)
     
163. *(p+i)=*(data+i);
     
164. return;
     
165. }
     
166. 
     
167. int* paixu_guibing(int* p,int leng,int (* cmp)(const void* a,const void* b))
     
168. {
     
169. if(leng<=1)
     
170. return p;
     
171. 
     
172. int zuo_leng=leng/2;
     
173. int you_leng=leng-zuo_leng;
     
174. int* zuo_data=new int[zuo_leng];
     
175. int* you_data=new int[you_leng];
     
176. 
     
177. for(int i=0;i<zuo_leng;i++)
     
178. {
     
179. *(zuo_data+i)=*(p+i);
     
180. *(you_data+i)=*(p+i+zuo_leng);
     
181. }
     
182. if(0!=leng/2)
     
183. *(you_data+you_leng-1)=*(p+leng-1);
     
184. 
     
185. zuo_data=paixu_guibing(zuo_data,zuo_leng,cmp);
     
186. you_data=paixu_guibing(you_data,you_leng,cmp);
     
187. return guibing_hebing(zuo_data,zuo_leng,you_data,you_leng,cmp);
     
188. }
     
189. 
     
190. int* guibing_hebing(int* zuo_data,int zuo_leng,int* you_data,int you_leng,int (* cmp)(const void* a,const void* b))
     
191. {
     
192. int* data=new int[zuo_leng+you_leng];
     
193. 
     
194. int zuo=0;
     
195. int you=0;
     
196. 
     
197. while(zuo<zuo_leng&&you<you_leng)
     
198. {
     
199. if(0>=cmp((zuo_data+zuo),(you_data+you)))
     
200. {
     
201. *(data+zuo+you)=*(zuo_data+zuo);
     
202. zuo++;
     
203. }
     
204. else
     
205. {
     
206. *(data+zuo+you)=*(you_data+you);
     
207. you++;
     
208. }
     
209. }
     
210. while(zuo<zuo_leng)
     
211. data[zuo+you]=zuo_data[zuo++];
     
212. while(you<you_leng)
     
213. data[zuo+you]=you_data[you++];
     
214. 
     
215. return data;
     
216. }
     
217. 
     
218. void paixu_kuaisu(int* p,int leng,int (* cmp)(const void* a,const void* b))
     
219. {
     
220. int* stack=new int[leng*2];
     
221. int top=0;
     
222. int tou=0;
     
223. int wei=leng-1;
     
224. int index;
     
225. 
     
226. while(tou<wei)
     
227. {
     
228. index=kuaisu_dingwei(p,tou,wei,cmp);
     
229. 
     
230. stack[top++]=index+1;
     
231. stack[top++]=wei;
     
232. wei=index-1;
     
233. while(tou>=wei&&top)
     
234. {
     
235. wei=stack[--top];
     
236. tou=stack[--top];
     
237. }
     
238. }
     
239. 
     
240. return;
     
241. }
     
242. 
     
243. int kuaisu_dingwei(int *p,int tou,int wei,int (* cmp)(const void* a,const void* b))
     
244. {
     
245. int data=p[tou+(wei-tou)/2];
     
246. p[tou+(wei-tou)/2]=p[tou];
     
247. 
     
248. while(tou<wei)
     
249. {
     
250. while(tou<wei&&0<=cmp((p+wei),&data))
     
251. wei--;
     
252. *(p+tou)=*(p+wei);
     
253. 
     
254. while(tou<wei&&0>=cmp((p+tou),&data))
     
255. tou++;
     
256. *(p+wei)=*(p+tou);
     
257. 
     
258. }
     
259. *(p+tou)=data;
     
260. return tou;
     
261. }
     
262. 
     
263. void paixu_maopao(int* p,int leng,int (* cmp)(const void* a,const void* b))
     
264. {
     
265. int data;
     
266. 
     
267. for(int i=0;i<leng-1;i++)
     
268. {
     
269. for(int j=leng-1;j>i;j--)
     
270. {
     
271. if(0>cmp((p+j),(p+j-1)))
     
272. {
     
273. data=*(p+j);
     
274. *(p+j)=*(p+j-1);
     
275. *(p+j-1)=data;
     
276. }
     
277. }
     
278. }
     
279. return;
     
280. }
     
281. 
     
282. void paixu_xuanze(int* p,int leng,int (* cmp)(const void* a,const void* b))
     
283. {
     
284. int data;
     
285. 
     
286. for(int i=0;i<leng-1;i++)
     
287. {
     
288. for(int j=i;j<leng;j++)
     
289. {
     
290. if(0>cmp((p+j),(p+i)))
     
291. {
     
292. data=*(p+i);
     
293. *(p+i)=*(p+j);
     
294. *(p+j)=data;
     
295. }
     
296. }
     
297. }
     
298. return;
     
299. }
     
300. 
     
301. void paixu_charu(int *p,int leng,int (* cmp)(const void* a,const void* b))
     
302. {
     
303. int data;
     
304. int index;
     
305. 
     
306. for(int i=1;i<leng;i++)
     
307. {
     
308. data=*(p+i);
     
309. index=i;
     
310. while(index>0&&0>cmp(&data,(p+index-1)))
     
311. {
     
312. *(p+index)=*(p+index-1);
     
313. index--;
     
314. }
     
315. *(p+index)=data;
     
316. }
     
317. 
     
318. return;
     
319. }
     
320. 
     
321. void paixu_xier(int* p,int leng,int (* cmp)(const void* a,const void* b))
     
322. {
     
323. int index;
     
324. int data;
     
325. int n;
     
326. 
     
327. for(n=leng/2;n>0;n/=2)
     
328. {
     
329. for(int i=n;i<leng;i++)
     
330. {
     
331. data=p[i];
     
332. index=i-n;
     
333. while(index>=0&&0>cmp(&data,(p+index)))
     
334. {
     
335. p[index+n]=p[index];
     
336. index-=n;
     
337. }
     
338. p[index+n]=data;
     
339. }
     
340. }
     
341. return;
     
342. }
     
343. 
     
344. int* paixu_yiersan(int* p,int leng,int (* cmp)(const void* a,const void* b))
     
345. {
     
346. int max=0;
     
347. for(int i=0;i<leng;i++)
     
348. if(max<p[i])
     
349. max=p[i];
     
350. 
     
351. int* index=new int[max+1];
     
352. int* data=new int[leng];
     
353. bool shunxu=true;
     
354. int a=1;
     
355. int b=2;
     
356. if(0<cmp(&a,&b))
     
357. shunxu=false;
     
358. 
     
359. memset(index,0,(max+1)*sizeof(int));
     
360. 
     
361. for(int i=0;i<leng;i++)
     
362. index[p[i]]++;
     
363. 
     
364. for(int i=1;i<=max;i++)
     
365. index[i]+=index[i-1];
     
366. 
     
367. for(int i=leng-1;i>=0;i--)
     
368. {
     
369. if(shunxu)
     
370. data[index[p[i]]-1]=p[i];
     
371. else
     
372. data[leng-index[p[i]]]=p[i];
     
373. index[p[i]]--;
     
374. }
     
375. 
     
376. return data;
     
377. }
     
378. 
     
379. void paixu_dui(int* p,int leng,int (* cmp)(const void* a,const void* b))
     
380. {
     
381. int data;
     
382. for(int i=leng/2;i>=0;i--)
     
383. dui_jian(p,i,leng,cmp);
     
384. 
     
385. for(int i=leng-1;i>0;i--)
     
386. {
     
387. data=p[0];
     
388. p[0]=p[i];
     
389. p[i]=data;
     
390. dui_jian(p,0,i-1,cmp);
     
391. }
     
392. 
     
393. return;
     
394. }
     
395. 
     
396. void dui_jian(int* p,int s,int leng,int (* cmp)(const void* a,const void* b))
     
397. {
     
398. int data=p[s];
     
399. 
     
400. for(int i=2*s;i<leng;i*=2)
     
401. {
     
402. if(i<leng&&0>cmp((p+i),(p+i+1)))
     
403. i++;
     
404. if(0<=cmp(&data,(p+i)))
     
405. break;
     
406. p[s]=p[i];
     
407. s=i;
     
408. }
     
409. p[s]=data;
     
410. return;
     
411. }
     
412. 
     
413. void paixu_geshibai(int* p,int leng,int (* cmp)(const void* a,const void* b))
     
414. {
     
415. int max=1;
     
416. int x=1;
     
417. int n=0;
     
418. int p_index=0;
     
419. int* p_data[10];
     
420. int data_index[10]={0};
     
421. bool max_xunzhao=true;
     
422. 
     
423. bool shunxu=true;
     
424. int a=1;
     
425. int b=2;
     
426. if(0<cmp(&a,&b))
     
427. shunxu=false;
     
428. 
     
429. for(int i=0;i<10;i++)
     
430. p_data[i]=new int[leng];
     
431. 
     
432. while(x<=max)
     
433. {
     
434. for(int i=0;i<leng;i++)
     
435. {
     
436. if(max_xunzhao)
     
437. if(max<p[i])
     
438. max=p[i];
     
439. if(x>p[i])
     
440. p_data[0][data_index[0]++]=p[i];
     
441. else
     
442. {
     
443. n=(p[i]/x)%10;
     
444. p_data[n][data_index[n]++]=p[i];
     
445. }
     
446. }
     
447. if(shunxu)
     
448. for(int i=0;i<10;i++)
     
449. {
     
450. for(int j=0;j<data_index[i];j++)
     
451. p[p_index++]=p_data[i][j];
     
452. data_index[i]=0;
     
453. }
     
454. else
     
455. for(int i=9;i>=0;i--)
     
456. {
     
457. for(int j=0;j<data_index[i];j++)
     
458. p[p_index++]=p_data[i][j];
     
459. data_index[i]=0;
     
460. }
     
461. x*=10;
     
462. p_index=0;
     
463. max_xunzhao=false;
     
464. }
     
465. return;
     
466. }
     
467. 
     
468. int paixu_fangfa(const void* a,const void* b)
     
469. {
     
470. return *(int*)a-*(int*)b;
     
471. }

复制代码

备注版~~~

排序_PK.rar (4.12 KB, 下载次数: 17, 售价: 3 鱼币)

2011-7-22 18:42 上传

点击文件名下载附件

raotf

沙发自己做~~~
没注释是偶的一贯作风~~~

仰望天上的光

（1）这些排序方法不实用，建议参考qsort函数，实现一个增强版本的qsort函数，可以指定排序算法。
（2）这些都是基于比较的排序，速度太慢，还可以加上 计数排序，基数排序  这些非基于比较的速度更快的排序法。

LNH_Sniper

raotf 发表于 2011-7-6 14:39

                               
登录/注册后可看大图

沙发自己做~~~
没注释是偶的一贯作风~~~

执行效率，相信在学的时候，已经有所了解了。应用到实际问题中吧。
与君共勉

服气

额 楼主写代码时加上注释好不？  我看着头晕哈
不过效率都不高 还是多看看算法吧 我也正在学呢

raotf

仰望天上的光 发表于 2011-7-6 14:46

                               
登录/注册后可看大图

（1）这些排序方法不实用，建议参考qsort函数，实现一个增强版本的qsort函数，可以指定排序算法。
（2）这 ...

我擦~~~~
指定排序方法!!!!!!!!!
快排竟然需要多用近5倍时间~~~~
本来只需qsort的1/3左右,加后就比qsort慢多了~~~~

然后问下想把比较类型int*改为void*
就是不知道怎么索引和交换数据
比如说
我想把p [ i ] 和p[i+1]的数据交换
但不知道p是结构体还是整型该怎么弄......
先谢了

raotf

服气 发表于 2011-7-6 22:48

                               
登录/注册后可看大图

额 楼主写代码时加上注释好不？  我看着头晕哈
不过效率都不高 还是多看看算法吧 我也正在学呢

效率都不高????
那排序什么高啊~~~
最常用的应该是快排把
非比较的排序好像都有局限性啊!!!

Be_envious

楼主 有点折腾人啊 下次 直接发二进制码 比较好

raotf

Be_envious 发表于 2011-7-11 17:22  楼主 有点折腾人啊 下次 直接发二进制码 比较好

好吧-_-
有时间我就把备注加上

cqk2980

无回帖，不论坛，这才是人道。

我挖

看帖，回复支持下

fishmo

看看老帖，支持下

fishmo

万恶的回复啊

都市小矮人

强烈支持！！！

★→初始化

谢谢分享！