听说快速排序是排序最快的一种，哪位大神说说怎么搞啦

设置两个变量i,j，排序开始的时候，i=0,j=length-1.
以第i个数组元素作为关键数据，赋值给key，用于比较。
从j开始向前搜索，即由后向前搜索(j--)，找到第一个小于key的值[j]，将[j]和位置的值进行互换。
从i开始向后搜索，即有开始向后搜索（i++），找到第一个比key小的值,将和[j]位置的值进行互换。
直到i>j循环结束。
对左侧（0,i-1）进行循环排序。
对左侧（j+1,length-1）进行循环排序。

1. package com.demo.test;
   
2. 
   
3. 
   
4. /**
   
5. * @author 史云龙
   
6. * 完成数组的快速排序
   
7. * 数组【100,40,60,87,34,11,56,0】
   
8. *快速排序：
   
9. *从小到大排列
   
10. */
    
11. public class QuickSort {
    
12.        
    
13.         /**
    
14.          * @param args
    
15.          * 主函数
    
16.          */
    
17.         public static void main(String[] args) {
    
18.                
    
19.                 int[] array = {100,40,60,87,34,11,56,0};
    
20.                 sop("未进行快速排序的数组：");
    
21.                 print(array);
    
22.                 sop("已经进行快速排序的数组：");
    
23.                 sort(array,0,array.length-1);
    
24.                 print(array);
    
25.         }
    
26.        
    
27.         /**
    
28.          * @param array【需要排序的数组】
    
29.          * @param low【最低位】
    
30.          * @param high【最高位】
    
31.          * 快速排序[从小到大排序]
    
32.          * 算法说明：
    
33.          *         1、设置两个变量，low,high,初始排序时，low=0，high=array.length-1;
    
34.          *                         第6步中，由于需要对分成的两部分数组继续进行排序，
    
35.          *                         需要定义两个变化的值来分别初始low和high，这里定义为l、h;
    
36.          * 2、以第l个数组元素作为关键数据，赋值给key，即key=array[l]
    
37.          * 3、从h开始向前搜索，即由后向前搜索，找到第一个小于key的值array[h]，
    
38.          *                 将array[h]和array[l]互换，此后key为array[h]
    
39.          * 4、从l开始向后搜索，即由前向后搜索，找到第一个大于key的值array[l]，
    
40.          *                 将array[l]和array[h]互换，此后key为array[l]
    
41.          * 5、第一次排序结束后，如果l<h，则重复第3、4两步。
    
42.          * 6、如果l>h是排序结束，左侧即【low----l】不一定是符合顺序的，则对左侧排序。
    
43.          *                 同时右侧【h----high】也不一定是符合顺序的，则对左侧进行排序的
    
44.          *                 由于此时l>=h，对左侧排序时将l进行-1，
    
45.          *                 对右侧进行排序时，将h进行+1,保证不会重复。
    
46.          *                 （1）l>h即l=h+1,不可能有其他情况，因为l=h+1时，循环已经结束。
    
47.          *                 从新开始的排序的两段数组顺序可以看做为【low-h】【l-high】,完全包含这个数组。
    
48.          *                 （2）l=h，
    
49.          *                 从新开始的排序的两段数组顺序可以看做为【low-l-1】【l=h】【h+1-high】,完全包含这个数组。
    
50.          *                 此时array[l]==array[h]大于左侧的数据，小于右侧的数据，可以不用重新排序。
    
51.          *                
    
52.          *
    
53.          */
    
54.         public static void sort(int[] array ,int low,int high){
    
55.                 //如果最小位置大于最大位置，直接返回。
    
56.                 if(low>=high)
    
57.                         return;
    
58.                 if((high-low)==1){
    
59.                         if(array[low]>array[high]){
    
60.                                 swap(array,low,high);
    
61.                         }
    
62.                         return;
    
63.                 }
    
64.                 //默认排序的KEY值
    
65.                 int key = array[low];
    
66.                 //将最低值赋给一个变量，用于一次排序后进行后续排序分组
    
67.                 int l = low;
    
68.                 //将最高值赋给一个变量，作用同上
    
69.                 int h=high;
    
70.                 //如果l<h,则一直进行循环
    
71.                 while(l<h){
    
72.                         //从最后向前找，找到比key小的第一个数
    
73.                         //如果l<h,且key比array[h]小，则一直循环
    
74.                         //直到h小于等于l或此时h处的值比key小，则结束循环
    
75.                         //找到比key小的值向前移动
    
76.                         while(l<h&&key<array[h])
    
77.                                 h--;
    
78.                         /*
    
79.                          与上述两行代码相同
    
80.                         while(l<h){
    
81.                                 if(array[h]<key)
    
82.                                         break;
    
83.                                 h--;
    
84.                         }
    
85.                         */
    
86.                         //交换l和h处位置的数据，key则是array[l]，交换，
    
87.                         //然后key就和array[h]相等，及此时key变换为array[h]
    
88.                         //交换的目的是将小点的数向前方移动
    
89.                         swap(array,l,h);
    
90.                         //从前向后找，找到比key（即array[h]）大的数
    
91.                         //如果l<h,且key(array[h])比array[l]大，则一直循环
    
92.                         //直到l大于等于h或此时l出的值比key大，则结束循环
    
93.                         //找到比key大的值向后移动
    
94.                         while(l<h&&key>array[l]){
    
95.                                 l++;
    
96.                         }
    
97.                         /*
    
98.                          与上述两行代码相同
    
99.                         while(l<h){
    
100.                                 if(array[l]>key)
     
101.                                         break;
     
102.                                 l++;
     
103.                         }
     
104.                         */
     
105.                         //交换l和h处位置的数据，key则是array[h]，交换，
     
106.                         //然后key就和array[l]相等，及此时key变换为array[l]
     
107.                         //交换的目的是将小点的数向前方移动
     
108.                         swap(array,l,h);
     
109.                 }
     
110.                 //对数组的两部分继续排序
     
111.                 sort(array,low,l-1);
     
112.                 sort(array,h+1,high);
     
113. 
     
114.         }
     
115.         /**
     
116.          * @param b【传入数组并进行打印】
     
117.          */
     
118.         public static void print(int[] b){
     
119.                 for (int i=0;i<b.length;i++){
     
120.                         sop(b[i]);
     
121.                         if(i==b.length-1){
     
122.                                 sop("\n");
     
123.                         }else{
     
124.                                 sop(" , ");
     
125.                         }
     
126.                 }
     
127.                
     
128.         }
     
129. 
     
130.         /**
     
131.          * @param array
     
132.          * @param i
     
133.          * @param j
     
134.          * 将符合条件的数组数据交换位置
     
135.          */
     
136.         public static void swap(int[] array,int i,int j){
     
137.                 int temp = array[i];
     
138.                 array[i]=array[j];
     
139.                 array[j]=temp;
     
140.                
     
141.         }
     
142.         /**
     
143.          * @param obj[将obj输出]
     
144.          */
     
145.         public static void  sop(Object obj){
     
146.                 System.out.print(obj);
     
147.         }
     
148. }
     

复制代码

跟着学习一下！

Arrays.sort