1. /*
   
2.         目的：理解快速排序
   
3.         思路：用前后索引的移动把目标元素放到数组中正确的位置，此位置前边的元素比目标小，后边的比目标大
   
4.        
   
5.         步骤：具体已转注释
   
6. 
   
7.         sy 索引
   
8.         kp 快排..
   
9. 
   
10.         输出结果：
    
11. ---------------------------------
    
12. F:\MyCode\EditPlus_code>javac SortKPTest.java
    
13. F:\MyCode\EditPlus_code>java SortKPTest
    
14. -3  2  2  4  32  98
    
15. -----------------------------------
    
16. */
    
17. 
    
18. public class SortKPTest {
    
19.         //main
    
20.         public static void main(String[] args) {
    
21.                
    
22.                 int[] arr = new int[]{2, 4, -3, 32, 98, 2};
    
23.                
    
24.                 SortKP kp = new SortKP();
    
25.                 kp.kp(arr, 0, 5);                //对数组中0到5号元素进行排序;
    
26. 
    
27.                                                        
    
28.                 for(int x : arr) {                //遍历排序后的数组
    
29.                         System.out.print(" "+x+" ");
    
30.                 }
    
31.                 System.out.println();
    
32.         }
    
33. }
    
34. 
    
35. class SortKP{                //快速排序       
    
36.         public int sy(int[] a, int i, int j) {       
    
37.                
    
38.                 int v = a[i];        //把索引为i的元素保存到v中，寻找元素v在整个数组中排序后的位置
    
39. 
    
40. 
    
41.                 while(i<j) {                //只有当前索引小于后索引才进入循环
    
42.                
    
43.                         while(i<j && a[j]>=v) {
    
44. 
    
45.                                 j--;
    
46.                         }
    
47.                         a[i] = a[j];        //i和j 是前索引和后索引，前索引不变，后索引对应的元素和需要找位置的元素 v 比较，
    
48.                                                         //当发现 v 更小，就把后索引往前移，继续判断循环，
    
49.                                                         //当发现 v 更大，把后索引元素放到前索引元素位置（上边前索引元素已经保存在v中），
    
50.                                                         //此时，后索引 j所在的位置之后已经都比 v 大，往下走
    
51. 
    
52.                         while(i<j && a[i]<=v) {
    
53.                        
    
54.                                 i++;
    
55.                         }
    
56.                         a[j] = a[i];        //同理，后索引不变，前索引对应的元素和需要找位置的元素 v 比较，
    
57.                                                         //当发现 v 更大，就把前索引往后移，继续判断循环，
    
58.                                                         //当发现 v 更小，把 前索引元素放到 后索引元素位置，
    
59.                                                         //此时，后索引 i所在的位置之后已经都比 v 小，往下走
    
60.                                                         //接着进入下一次外循环
    
61.                 }
    
62. 
    
63.                 a[i] = v;                        //直到当 前后索引的位置重合，此时这个索引指向的位置就是 V 的位置（前边比v小，后边比v大）
    
64.                                                         //放到eclipse中通过断点查看此时的a[i]可知，v元素放到正确的位置
    
65.                 //或是 a[j] = v;
    
66. 
    
67.                 return i; //返回已经找到的元素的索引
    
68.        
    
69.         }
    
70. 
    
71.         public void kp(int[] a, int i, int j) {
    
72.                 int pos;        //创建一个记录位置的变量，用来记录上边 sy方法返回的位置，把数组分成前后两个部分继续排序
    
73. 
    
74.                 if(i<j) {        //当前索引i和后索引j之间有元素，才进行判断
    
75. 
    
76.                         pos = sy(a, i, j);        //返回一个排好元素的标号，把数组分成两半
    
77.                         kp(a, pos+1, j);        //排数组后边的元素
    
78.                         kp(a, i, pos-1);        //排数组前边的元素
    
79.                 }
    
80.         }
    
81. }

复制代码

哈哈哈，这么麻烦

后面就看迷糊了