排序算法之（三）快速排序

原理：
通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
思路：

1. 每次都拿分割好的序列的首元素（末元素）作为中轴进行分割
2. 第二次排序之后都在分割好的两部分中再次递归进行交换元素排序
3. 排好的中轴元素就不带他玩了

举例说明：
排序数组int[] arr={3,5,8,1,2,9,4,7,6};

---

第一次循环，
以3为中轴，从右->左找到比3小的数2，放在3的位置，
然后从左->右找到比3大的数5，放在2的位置，
再从左->右找到比3小的数1，放在5的位置，
然后从左->右找到比3大的数8，放在1的位置，
两指针相遇时，将中轴3置于最后一次的数8的位置；
{2,1,3,8,5,9,4,7,6}

---

第二次循环，
{2,1}以2为中轴，从右->左找到比2小的数1，放在2的位置，
从左->右未找到比2大的数，将中轴2放在最后一次的数1的位置；
{1,2,3,8,5,9,4,7,6}

---

第三次循环，
{1}以1为中轴，不需要做替换
{1,2,3,8,5,9,4,7,6}

---

第四次循环，
{8,5,9,4,7,6}以8为中轴，从右->左找到比8小的数6，放在8的位置，
从左->右找到比8大的数9，放在6的位置，
从右->左找到比8小的数7，放在9的位置，
两指针相遇时，将中轴8置于最后一次的数7的位置；
{1,2,3,6,5,7,4,8,9}

---

第五次循环，
{6,5,7,4}以6为中轴，从右->左找到比6小的数4，放在6的位置，
从左->右找到比6大的数7，放在4的位置，
两指针相遇时，将中轴6置于最后一次的数5的位置；
{1,2,3,4,5,6,7,8,9}

---

第六次循环，
{4,5}以4为中轴，不需要做替换
{1,2,3,4,5,6,7,8,9}

---

第七次循环，
{5}以5为中轴，不需要做替换
{1,2,3,4,5,6,7,8,9}

---

第八次循环，
{7}以7为中轴，不需要做替换
{1,2,3,4,5,6,7,8,9}

---

第九次循环，
{9}以9为中轴，不需要做替换
{1,2,3,4,5,6,7,8,9}

---

最终排序结果：{1,2,3,4,5,6,7,8,9}

Java代码实现：

package com.learn.demo.sort;
/**
 * 快速排序
 */
public class QuickSort1 {
    public static void main(String[] args) {
        int[] numbers = {3,5,8,1,2,9,4,7,6};
        System.out.print("排序前：");
        printArr(numbers);
        System.out.println();
        sort(numbers, 0, numbers.length-1);
        System.out.println();
        System.out.print("快速排序后：");
        printArr(numbers);
    }
    /**
     * @param arr 待排序数组
     * @param low 开始位置
     * @param high 结束位置
     */
    public static void sort(int arr[],int low,int high) {
        int l=low;
        int h=high;
        int povit = arr[low];

        while(l<h) {//左侧指标小于右侧指标
            while(l<h && arr[h]>=povit)//从右侧找数据大于中轴的那个数的下标
                h--;
            if(l<h){
                int temp=arr[h];
                arr[h]=arr[l];
                arr[l]=temp;
                l++;
            }
            while(l<h && arr[l]<=povit)//从左侧找数据大于中轴的那个数的下标
                l++;
            if(l<h){
                int temp=arr[h];
                arr[h]=arr[l];
                arr[l]=temp;
                h--;
            }
        }
        System.out.println("中轴="+povit);
        printArr(arr);
        if(l>low)sort(arr,low,l-1);//递归调用sort函数
        if(h<high)sort(arr,l+1,high);
    }
    public static void printArr(int[] numbers) {
        for(int i = 0 ; i < numbers.length ; i ++ ) {
            System.out.print(numbers[i] + ",");
        }
        System.out.println("");
    }
}

demo运行后控制台的输出如下图：

若数组中出现一样的元素时
举例：int [] arr = {3,3,8,1,2,9,4,7,6}
在进行第一次循环时结果为{2,3,1,3,8,9,4,7,6}，arr[1]不做变动，
而最后排序结果为{1,2,3,3,4,6,7,8,9}，
整个排序过程中arr[0]的3与arr[1]的3交换了位置，
原序列中2个3的相对位置前后顺序就破坏了，
所以快速排序不稳定