本实现方法，不仅可能对一个数组进行排序，也可以指定数组中部分元素进行排序，代码如下：

1. public class QuicSort {
   
2. 
   
3. /**
   
4. * 一趟快速排序的方法
   
5. *
   
6. * @param array
   
7. * 所要排序的数组
   
8. * @param h
   
9. * 排序子列的开始位置
   
10. * @param p
    
11. * 排序子列的结束位置
    
12. * @return 返回当前一趟快速排序后，比较关键字所处于的位置
    
13. */
    
14. private static int quickPass(int[] array, int h, int p) {
    
15. int i = h;
    
16. int j = p;
    
17. int x = array[i];// 比较所用的关键字
    
18. while (i < j) {
    
19. while ((array[j] >= x) && (i < j))
    
20. // 自尾端进行比较
    
21. j--;
    
22. if (i < j) {
    
23. array[i] = array[j];// 将小于关键字的记录移至i所指的位置，完成第一次交换
    
24. i++;
    
25. // 自首端进行比较
    
26. while ((array[i] <= x) && (i < j)) {
    
27. i++;
    
28. if (i < j) {
    
29. array[j] = array[i];// 将大于关键字的记录移到j所指的位置
    
30. j--;
    
31. }
    
32. }
    
33. }
    
34. }
    
35. array[i] = x;// 一趟快速排序完成，将x移至正确位置
    
36. return i;
    
37. }
    
38. 
    
39. /**
    
40. * 对一个数组的部分进行排序，
    
41. *
    
42. * @param array
    
43. * 排序的数组
    
44. * @param s
    
45. * 排序开始的位置
    
46. * @param t
    
47. * 所要排序结束的位置
    
48. */
    
49. public static void quickSort(int[] array, int s, int t) {
    
50. 
    
51. int i = 0;
    
52. if (s < t) {// 未做数组越界检查的代码
    
53. i = quickPass(array, s, t);
    
54. quickSort(array, s, i - 1);
    
55. quickSort(array, i + 1, t);
    
56. }
    
57. }
    
58. 
    
59. /**
    
60. * 对一个数组进行快速排序
    
61. *
    
62. * @param array
    
63. * 排序的数组
    
64. */
    
65. public static void quickSort(int[] array) {
    
66. 
    
67. int s = 0;
    
68. int t = array.length - 1;
    
69. int i = 0;
    
70. if (s < t) {
    
71. i = quickPass(array, s, t);
    
72. quickSort(array, s, i - 1);
    
73. quickSort(array, i + 1, t);
    
74. }
    
75. }
    
76. 
    
77. /**
    
78. * 输出排好序的数组
    
79. *
    
80. * @param array
    
81. */
    
82. private static void printArray(int[] array) {
    
83. System.out.print("排过序的数组：");
    
84. for (int a : array) {
    
85. System.out.print(a + " ");
    
86. }
    
87. System.out.println("");
    
88. }
    
89. 
    
90. public static void main(String[] args) {
    
91. int[] array1 = { 4, 1, 6, 3, 2, 9, 7 };
    
92. quickSort(array1);// 此方法对一个数组使用快速排序法做升序排序
    
93. System.out.println("对整个数组排序");
    
94. printArray(array1);
    
95. int[] array2 = { 4, 1, 6, 3, 2, 9, 7 };
    
96. // 此方法，提供了对数组部分元素的进行排序的功能，比如，只排序数组中的前五位：
    
97. quickSort(array2, 0, 4);
    
98. System.out.println("仅对数组中前五位元素进行排序");
    
99. printArray(array2);
    
100. 
     
101. }
     
102. }

复制代码

值得学习ing!

感觉楼主写得快排不是那么简化啊
我也发个我写的吧 参照了《数据结构(C语言版) 》(严蔚敏 & 吴伟民)
现在看 依然觉得上面的算法最优 无论是占用空间还是运行时间

1. package com.Lland;
   
2. 
   
3. public class Sort {// 快速排序
   
4.         public void quickSort(int[] array) {
   
5.                 subQuickSort(array, 0, array.length - 1);
   
6.         }
   
7. 
   
8.         private void subQuickSort(int[] array, int low, int high) {
   
9.                 if (low < high) {
   
10.                         int pivotTag = partitions(array, low, high);
    
11.                         subQuickSort(array, low, pivotTag - 1);
    
12.                         subQuickSort(array, pivotTag + 1, high);
    
13.                 }
    
14.         }
    
15. 
    
16.         private int partitions(int array[], int low, int high) {
    
17.                 int pivotKey = array[low];
    
18.                 while (low < high) {
    
19.                         while (low < high && array[high] >= pivotKey)
    
20.                                 high--;
    
21.                         array[low] = array[high];
    
22.                         while (low < high && array[low] <= pivotKey)
    
23.                                 low++;
    
24.                         array[high] = array[low];
    
25.                 }
    
26.                 array[low] = pivotKey;
    
27.                 return low;
    
28.         }
    
29. }

复制代码

然后主方法：

1. package com.Lland;
   
2. 
   
3. import java.util.Random;
   
4. 
   
5. public class MainClass {
   
6.         public static void main(String[] args) {
   
7.                 //申明要用的对象
   
8.                 Random r = new Random();
   
9.                 int[] i = new int[20];
   
10.                 Sort s = new Sort();
    
11.                 //随机化数组
    
12.                 for(int j = 0; j < i.length; j++){
    
13.                         i[j] = r.nextInt(100) + 1;
    
14.                 }
    
15.                 //打印数组
    
16.                 for(int j = 0; j < i.length; j++){
    
17.                         System.out.print(i[j]);
    
18.                         if(j < i.length){
    
19.                                 System.out.print(", ");
    
20.                         }
    
21.                 }
    
22.                 System.out.println();
    
23.                 //快排
    
24.                 s.quickSort(i);
    
25.                 //打印数组
    
26.                 for(int j = 0; j < i.length; j++){
    
27.                         System.out.print(i[j]);
    
28.                         if(j < i.length){
    
29.                                 System.out.print(", ");
    
30.                         }
    
31.                 }
    
32.                 System.out.println();
    
33.         }
    
34. }

复制代码

但是这个也有缺点
是用最低位来做对比值所以还有平衡排序
思想是用最低位和最高位以及中间位3为数中 不大不小的那位来做关键值