Java排序以及简单的快速排序

1、首先排序的方法有很多种：插入排序，冒泡排序，堆排序，归并排序，选择排序，计数排序，基数排序，桶排序，快速排序等

 

这里是主要讲解一下快速排序这个方法，我也是看了好几篇文章才看明白的：

1、先在待排序的一组数据中随便选一个数出来作为基数：key；

2、然后对这组数进行排序，比key小的放key的左边，比key大的放key的右边，当然这个按照需求来（从小到大，还是从大到小）

3、递归的来分组，在第二步中在将这个组数字，分成多个小组来排序就可以了

 

具体看代码来理解，可能会更加好理解

[java] view plaincopy

1. package com.itheima;  
2.   
3. /** 
4.  * 4、 排序有哪几种方法？请列举。并用JAVA实现一个快速排序. 
5.  * 排序的方法有：冒泡排序、快速排序、选择排序、插入排序。。。 
6.  *  
7.  * @author [e-mail] 
8.  */  
9.   
10. public class Test4 {  
11.   
12.     static int count = 0;  
13.       
14.     public static void main(String[] args) {  
15.         int values[] = { 5, 4, 8, 3, 7, 2, 1, 9, 0, 6 };  
16.   
17.         qsort(values, 0, (values.length - 1));  
18.   
19.         System.out.printf("\n\n排序后的结果是：");  
20.         for (int i = 0; i < values.length; i++) {  
21.             System.out.printf("%d ", values[i]);  
22.         }  
23.     }  
24.   
25.     public static void qsort(int values[], int left, int right) {  
26.         int tmp = 0;  
27.   
28.         System.out.printf("\n这个是第%d次排序的结果：", count);  
29.         count++;  
30.         for (int i = 0; i < values.length; i++) {  
31.             System.out.printf("%d ", values[i]);  
32.         }  
33.           
34.         if (left < right) {  
35.             tmp = partition(values, left, right);  
36.             qsort(values, left, tmp);  
37.             qsort(values, tmp + 1, right);  
38.         }  
39.     }  
40.   
41.     public static int partition(int values[], int left, int right) {  
42.         int i = 0, j = 0;  
43.         int key = 0, tmp = 0;  
44.   
45.         if (null == values) {  
46.             return 0;  
47.         }  
48.   
49.         i = left;  
50.         j = right;  
51.         key = values[left];  
52.   
53.         // 这个while循环可以实现排序的第一步：分组  
54.         while (i < j) {  
55.             while (values[j] > key) {  
56.                 --j;  
57.             }  
58.             tmp = values[i];  
59.             values[i] = values[j];  
60.             values[j] = tmp;  
61.   
62.             while (values[i] < key) {  
63.                 i++;  
64.             }  
65.             tmp = values[i];  
66.             values[i] = values[j];  
67.             values[j] = tmp;  
68.         }  
69.   
70.         return i;  
71.   
72.     }  
73. }  

下面是每次排序的结果：

[plain] view plaincopy

1. 这个是第0次排序的结果：5 4 8 3 7 2 1 9 0 6   
2. 这个是第1次排序的结果：0 4 1 3 2 5 7 9 8 6   
3. 这个是第2次排序的结果：0 4 1 3 2 5 7 9 8 6   
4. 这个是第3次排序的结果：0 4 1 3 2 5 7 9 8 6   
5. 这个是第4次排序的结果：0 2 1 3 4 5 7 9 8 6   
6. 这个是第5次排序的结果：0 1 2 3 4 5 7 9 8 6   
7. 这个是第6次排序的结果：0 1 2 3 4 5 7 9 8 6   
8. 这个是第7次排序的结果：0 1 2 3 4 5 7 9 8 6   
9. 这个是第8次排序的结果：0 1 2 3 4 5 7 9 8 6   
10. 这个是第9次排序的结果：0 1 2 3 4 5 7 9 8 6   
11. 这个是第10次排序的结果：0 1 2 3 4 5 7 9 8 6   
12. 这个是第11次排序的结果：0 1 2 3 4 5 7 9 8 6   
13. 这个是第12次排序的结果：0 1 2 3 4 5 7 9 8 6   
14. 这个是第13次排序的结果：0 1 2 3 4 5 6 7 8 9   
15. 这个是第14次排序的结果：0 1 2 3 4 5 6 7 8 9   
16. 这个是第15次排序的结果：0 1 2 3 4 5 6 7 8 9   
17. 这个是第16次排序的结果：0 1 2 3 4 5 6 7 8 9   
18. 这个是第17次排序的结果：0 1 2 3 4 5 6 7 8 9   
19. 这个是第18次排序的结果：0 1 2 3 4 5 6 7 8 9   
20.   
21. 排序后的结果是：0 1 2 3 4 5 6 7 8 9