快速排序

思想（升序）：

　　1.将第一个数a与其他数据挨个比较，如果a大于其他数据中的那个值，就将这个值和a交换，通过这次比较会选出一个最小值；

　　2.将上次选出的最小值排除，之后将第二个数b与其他数据挨个比较，重复第1，2步；

　　3.直到选出的最小值的个数为数组长度-1时，排序结束；

比如：数组为{10　　,34　　,300　　,56　　,6,　　56　　,7　　,87　　,　　5}数组长度为9；

public class find_em {
    public static void main(String[] args){
        int arr[]={10,34,300,56,6,56,7,87,5};
        System.out.println("原始数据：");
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+"\t");
        }
        System.out.println("\n排序(升序)：");
        int compare=0;
        int swap=0;

        
        //快速排序
        for(int i=0;i<arr.length-1;i++){　　//确定被比较的数，被比较的数的取值范围{10,34,300,56,6,56,7,87,5}
            for(int j=i+1;j<arr.length;j++){　　　　//确定比较的数据
                if(arr[i]>arr[j]){
                    int t=arr[i];
                    arr[i]=arr[j];
                    arr[j]=t;
                    swap++;
                }
                compare++;
            }
            for(int e=0;e<arr.length;e++){
                System.out.print(arr[e]+"\t");
            }
            System.out.println("选出本次最小值："+arr[i]);
        }
        System.out.println("排序后的数据：");
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+"\t");
        }
        System.out.println();
        System.out.println("比较次数："+compare);
        System.out.println("交换次数："+swap);
    }
}

结果：

原始数据：
10    34    300    56    6    56    7    87    5    
排序(升序)：
5    34    300    56    10    56    7    87    6    选出本次最小值：5
5    6    300    56    34    56    10    87    7    选出本次最小值：6
5    6    7    300    56    56    34    87    10    选出本次最小值：7
5    6    7    10    300    56    56    87    34    选出本次最小值：10
5    6    7    10    34    300    56    87    56    选出本次最小值：34
5    6    7    10    34    56    300    87    56    选出本次最小值：56
5    6    7    10    34    56    56    300    87    选出本次最小值：56
5    6    7    10    34    56    56    87    300    选出本次最小值：87
排序后的数据：
5    6    7    10    34    56    56    87    300    
比较次数：36
交换次数：18

与冒泡排序（可看我的上一篇文章http://www.cnblogs.com/feiquan/p/8973300.html）相比：

　快速排序的交换次数比冒泡排序的少，而且如果数据越多，这种差距会越明显；