排序算法java版

转 http://www.blogjava.net/luluyanglu/archive/2011/10/07/360090.html

本文思路部分来源于上篇文章，但测得的结果似乎不大相同，不知是因为java的缘故还是因为我算法的缘故，欢迎拍砖。

复习排序，顺便比下各种算法的速度，榜单如下：

1、冒泡排序

2、简单选择排序

3、直接插入排序

4、折半插入排序

5、希尔排序

6、堆排序

7、归并排序

8、快速排序

不稳定：快速排序，希尔排序，堆排序。

当然这是慢速排行，哈哈~~

直接上图：单位毫秒

数量	冒泡排序	简单选择排序	直接插入排序	折半插入排序	希尔排序	堆排序	归并排序	快速排序
10000个	1578	1250	672	250	0	15	16	0
15000个	3453	2765	1563	531	16	15	16	0
20000个	6140	4547	2453	828	16	16	15	16
25000个	10079	7171	3969	1313	31	16	15	16
30000个	14641	10313	5578	1906	31	31	16	31
35000个	20141	14328	7890	2563	31	31	32	15
40000个	25766	18359	10094	3422	47	31	31	32
45000个	32469	24063	13062	4359	47	47	31	47

由于"希尔排序","堆排序","归并排序","快速排序"太快，以至于在上图几乎是条直线，故有了下面转为他们准备的加强版

数量	希尔排序	堆排序	归并排序	快速排序
100000个	172	140	110	93
200000个	469	406	235	234
300000个	812	703	422	375
400000个	1125	1031	516	531
500000个	1406	1282	719	656
600000个	1828	1703	860	859
700000个	2531	2063	1000	968
800000个	2735	2453	1140	1188
900000个	3047	2843	1391	1266
1000000个	3375	3187	1516	1422
1100000个	3922	3500	1625	1609
1200000个	4421	3954	1969	1812
1300000个	4797	4422	2000	1953
1400000个	5391	4797	2547	2094
1500000个	5437	5219	2625	2328
1600000个	6203	5546	2469	2485
1700000个	6532	5953	2844	2672
1800000个	7125	6421	2984	2844

补上代码：

Java代码

1. import java.util.ArrayList;
2. import java.util.Arrays;
3. import java.util.List;
4. 
   
5. public class SortTest {
6. 
   
7. public static void main(String[] args)throws Exception {
8. //测试排序是否正确
9. //String[] testErr=new String[]{"冒泡排序","简单选择排序","直接插入排序","折半插入排序","系尔排序","堆排序","归并排序","快速排序"};
10. //new SortTest().testErr(testErr);
11. 
    
12. //排序1（全部）
13. String[] strs=new String[]{"冒泡排序","简单选择排序","直接插入排序","折半插入排序","希尔排序","堆排序","归并排序","快速排序"};
14. new SortTest().test(strs,10000,50000,5000);
15. 
    
16. //排序2（加强）
17. String[] strs2=new String[]{"希尔排序","堆排序","归并排序","快速排序"};
18. new SortTest().test(strs2,100000,1900000,100000);
19. 
    
20. }
21. private void testErr(String[] strings) throws Exception{
22. 
    
23. //System.out.println(Arrays.toString(old));
24. System.out.println(Arrays.toString(strings));
25. 
    
26. Number[] old=getRundom(50);
27. Integer[] oo={1,2,3,3,2,21,5,6,7,78,5,65,8,7,6,6,6,6,6,9,56544,354,32,4,456,8,89,-9,0,3,243,-321,321,-3,-2,21};
28. old=oo;
29. for(String s:strings){
30. Number[] testNum=Arrays.copyOf(old, old.length);
31. long begin=System.currentTimeMillis();
32. SortTest.class.getMethod(s, Number[].class).invoke(this, (Object)testNum);
33. 
    
34. long end=System.currentTimeMillis();
35. System.out.println(s+":"+(end-begin)+"\t");
36. System.out.println(Arrays.toString(testNum));
37. }
38. System.out.println();
39. 
    
40. 
    
41. }
42. 
    
43. private void test(String[] strings,long begin,long end,long step) throws Exception{
44. System.out.print("数量\t");
45. for(String str:strings){
46. System.out.print(str+"\t");
47. }
48. System.out.println();
49. for(long i=begin;i
50. System.out.print(i+"个\t");
51. Number[] old=getRundom(i);
52. for(String s:strings){
53. Number[] testNum=Arrays.copyOf(old, old.length);
54. long beginTime=System.currentTimeMillis();
55. SortTest.class.getMethod(s, Number[].class).invoke(this, (Object)testNum);
56. 
    
57. long endTime=System.currentTimeMillis();
58. System.out.print((endTime-beginTime)+"\t");
59. //System.out.println(Arrays.toString(testNum));
60. }
61. System.out.println();
62. }
63. 
    
64. }
65. 
    
66. private static Integer[] getRundom(long num) {
67. List list=new ArrayList();
68. for(long i=0;i
69. int k;
70. if(Math.random()>0.5){
71. k=(int)(Math.random()*Integer.MAX_VALUE);
72. }else{
73. k=(int)(Math.random()*Integer.MIN_VALUE);
74. }
75. list.add(k);
76. }
77. return list.toArray(new Integer[list.size()]);
78. }
79. 
    
80. 
    
81. 
    
82. 
    
83. public static void 直接插入排序(Number[] data)
84. {
85. Number tmp=null ;
86. 
    
87. for(int i=1;i
88. tmp = data[i];
89. int j=i-1;
90. while(j>=0 && tmp.doubleValue()
91. data[j+1]=data[j];
92. j--;
93. }
94. data[j+1]=tmp;
95. }
96. }
97. public static void 折半插入排序(Number[] data)
98. {
99. Number tmp=null ;
100. for(int i=1;i
101. tmp = data[i];
102. int smallpoint=0;
103. int bigpoint=i-1;
104. 
     
105. while(bigpoint>=smallpoint){
106. int mid=(smallpoint+bigpoint)/2;
107. if(tmp.doubleValue()>data[mid].doubleValue()){
108. smallpoint=mid+1;
109. }else{
110. bigpoint=mid-1;
111. }
112. }
113. for(int j=i;j>smallpoint;j--){
114. data[j]=data[j-1];
115. }
116. data[bigpoint+1]=tmp;
117. }
118. }
119. 
     
120. public static void 希尔排序(Number[] data)
121. {
122. int span=data.length/7;
123. if(span==0)span=1;
124. while(span>=1){
125. for(int i=0;i
126. for(int j=i;j
127. //组内直接插入排序
128. int p = j-span;
129. Number temp = data[j];
130. while( p >=0 && data[p].doubleValue() > temp.doubleValue()){
131. data[p+span] = data[p];
132. p -=span;
133. }
134. data[p + span] = temp;
135. }
136. }
137. span=span/2;
138. }
139. 
     
140. 
     
141. }
142. 
     
143. public static void 冒泡排序(Number[] data)
144. {
145. for (int i = 0; i < data.length; i++) {
146. //将相邻两个数进行比较，较大的数往后冒泡
147. for (int j = 0; j < data.length - i-1; j++) {
148. if (data[j].doubleValue()> data[j + 1].doubleValue()) {
149. //交换相邻两个数
150. swap(data, j, j + 1);
151. }
152. }
153. }
154. }
155. public static void 快速排序(Number[] data)
156. {
157. QuickSort(data,0,data.length-1);
158. }
159. 
     
160. private static void QuickSort(Number[] data, int begin, int end) {
161. // System.out.println(begin+":"+end);
162. if(begin
163. //取中点
164. int mid=(begin+end)/2;
165. if(data[end].doubleValue()
166. swap(data, end, begin);
167. }
168. if(data[end].doubleValue()
169. swap(data, end, mid);
170. }
171. if(data[mid].doubleValue()
172. swap(data, mid, begin);
173. }
174. 
     
175. swap(data, mid, begin);
176. 
     
177. // System.out.println(Arrays.toString(Arrays.copyOfRange(data, begin, end)) );
178. int min=begin+1;
179. int big=end;
180. 
     
181. while(true){
182. while(min
183. while(min=data[begin].doubleValue()){big--;}
184. if(min>=big){
185. break;
186. }
187. swap(data, min, big);
188. }
189. if(data[begin].doubleValue()>data[min].doubleValue()){
190. swap(data, begin, min);
191. }
192. 
     
193. if(min>1)
194. QuickSort(data,begin,min-1);
195. //if(min
196. QuickSort(data,min,end);
197. }
198. }
199. public static void 简单选择排序(Number[] data)
200. {
201. for (int i = 0; i < data.length-1; i++) {
202. int smallPoint=i;
203. for (int j = i+1; j < data.length; j++) {
204. if (data[smallPoint].doubleValue()> data[j].doubleValue()) {
205. smallPoint=j;
206. }
207. }
208. swap(data, i, smallPoint);
209. }
210. 
     
211. }
212. 
     
213. public static void 堆排序(Number[] data)
214. {
215. 
     
216. int n = data.length;
217. for(int i=n/2;i>=0;i--){
218. keepHeap(data, n, i);
219. }
220. while (n > 0) {
221. swap(data, 0, n-1);
222. keepHeap(data, --n, 0);
223. }
224. }
225. 
     
226. 
     
227. private static void keepHeap(Number[] a, int n, int i) {
228. Number x = a[i];
229. int j = 2 * i + 1;
230. while (j <= n - 1) {
231. if (j < n - 1 && a[j].doubleValue() < a[j + 1].doubleValue())
232. ++j;
233. if (a[j].doubleValue() > x.doubleValue()) {
234. a[i] = a[j];
235. i = j;
236. j = 2 * i ;
237. } else{
238. break;
239. }
240. }
241. a[i] = x;
242. }
243. 
     
244. 
     
245. 
     
246. 
     
247. public static void 归并排序(Number[] data)
248. {
249. Number[] result = merge_sort(data,0,data.length-1);
250. for(int i=0;i
251. data[i]=result[i];
252. }
253. }
254. private static Number[] merge_sort(Number[] array, int start, int end){
255. Number[] result = new Number[end-start+1];
256. if(start< end){
257. int mid= (start+end)/2;
258. Number[] left= merge_sort(array, start, mid);
259. Number[] right = merge_sort(array, mid+1, end);
260. result= merge(left,right);
261. } else if (start == end) {
262. result[0] = array[start];
263. return result;
264. }
265. return result;
266. }
267. private static Number[] merge(Number[] left, Number[] right) {
268. Number[] result = new Number[left.length+right.length];
269. int i=0;
270. int j=0;
271. int k=0;
272. while(i< left.length&&j< right.length){
273. if(left[i].doubleValue()< right[j].doubleValue()){
274. result[k++] = left[i++];
275. }else{
276. result[k++] = right[j++];
277. 
     
278. }
279. }
280. while(i< left.length){
281. result[k++] = left[i++];
282. }
283. while (j< right.length) {
284. result[k++]= right[j++];
285. }
286. return result;
287. }
288. 
     
289. private static void swap(Number[] data, int x, int y) {
290. Number temp = data[x];
291. data[x] = data[y];
292. data[y] = temp;
293. }
294. }