简单易懂：快速排序算法

概念

1. 快速排序(Quicksort)是对冒泡排序的一种改进。
2. 快速排序由C. A. R. Hoare在1962年提出。它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
3. 在排序的过程中，由于已经分开的两部分的元素不需要进行比较，故减少了比较的次数，降低了排序时间。

介绍

1. 首先在要排序的区域a 中选取一个基准值，而后将区域分成两个分区，其中左分区 b 中的元素均小于或者等于基准值，右分区 c 的元素 均大于或者等于基准值，而后通过递归调用快速排序的过程分别对两个分区再次进行排序，最后将两个分区产生的结果合并即可得到最后的排序序列。
2. “基准值”的选择有很多种方法。最简单的是使用分区中第一个元素值。但是如果输入的数组是正序或者逆序的，就会将所有的记录分到“基准值”的一边。较好的方法是随机选取“基准值”，这样可以减少原始输入对排序造成的影响。但是随机选取“基准值”的开销大。

代码实现

package com.day05;

public class QuickSort {
 
    private static int[] array = {8,1,10,2,7,9,4,3,5,11,6};
 
    public static void main(String[] args){
        System.out.println("原数组array的值：");
        for (int i : array ) {
            System.out.print(i+" ");
        }
        System.out.println();
        System.out.println();
        quickSort(0, array .length-1);
    }
 
    public static void quickSort(int left,int right){
        int i,j,temp;
        if(left>right){
            return;
        }
        temp=array [left]; //temp中存的就是基准数
        i=left;
        j=right;
        while(i!=j){
            //顺序很重要，要先从右边开始找 ，直到找到一个小于基准的值
            while(array [j]>=temp && i<j){
                j--;
            }
            //再找右边的 ，直到找到一个大于基准的值
            while(array [i]<=temp && i<j){
                i++;
            }
            //交换两个数在数组中的位置
            if(i<j) {
                int t=array [i];
                array [i]=array [j];
                array [j]=t;      
                System.out.println("交换 ("+array [i]+") 和 ("+array [j]+") 值后：");
                for (int k : array ) {
                    System.out.print(k+" ");
                }
                System.out.println();
                System.out.println();
            }
       }
        //最终将基准数归位
        array [left]=array [i];
        array [i]=temp;
        System.out.println("基准值 ("+temp+") 归位后，数组array：");
        for (int k : array ) {
            System.out.print(k+" ");
        }
        System.out.println();
        System.out.println();
        if(left<i-1){
            quickSort(left,i-1);//继续处理左边的，这里是一个递归的过程
        }
        if(right>j+1){
            quickSort(i+1,right);//继续处理右边的 ，这里是一个递归的过程
        }
    }
}



运行结果：

原数组array的值：
8 1 10 2 7 9 4 3 5 11 6 

交换 (6) 和 (10) 值后：
8 1 6 2 7 9 4 3 5 11 10 

交换 (5) 和 (9) 值后：
8 1 6 2 7 5 4 3 9 11 10 

基准值 (8) 归位后，数组array：
3 1 6 2 7 5 4 8 9 11 10 

交换 (2) 和 (6) 值后：
3 1 2 6 7 5 4 8 9 11 10 

基准值 (3) 归位后，数组array：
2 1 3 6 7 5 4 8 9 11 10 

基准值 (2) 归位后，数组array：
1 2 3 6 7 5 4 8 9 11 10 

交换 (4) 和 (7) 值后：
1 2 3 6 4 5 7 8 9 11 10 

基准值 (6) 归位后，数组array：
1 2 3 5 4 6 7 8 9 11 10 

基准值 (5) 归位后，数组array：
1 2 3 4 5 6 7 8 9 11 10 

基准值 (9) 归位后，数组array：
1 2 3 4 5 6 7 8 9 11 10 

基准值 (11) 归位后，数组array：
1 2 3 4 5 6 7 8 9 10 11