简介

首先还是得简单的介绍一下快速排序这个算法。
快速排序（Quicksort），又称划分交换排序（partition-exchange sort），一种排序算法，最早由东尼·霍尔提出。在平均状况下，排序n个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n)算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。
快速排序也是被称作21世纪最伟大算法之一。

NO PIC SAY WHAT?

    每个（未排序）的拆分的遍历
        将第一个元素设为轴心点
          存储指数 = 轴心点指数 +1
          从 i=轴心点指数 +1 到 最右指数 的遍历
            如果 元素[i] < 元素[轴心点]
              交换(i, 存储指数); 存储指数++
          交换(轴心点, 存储指数 - 1)

实现的思路是选择一个元素，将比他小的放在他的左边，比他大的放右边，递归完所有未完成排序的数组即可完成最后的目标。

java 实现

    public static void main(String[] args) {
        int[] test = {6, 9, 28 ,13 ,31 ,26 ,1 ,16 ,7, 22, 49 ,46,45,46};
        quicksort(test,0);
        for (int i = 0; i < test.length; i++) {
            System.out.print(test[i] + "\t");
        }
    }
    /**
     * 每个（未排序）的拆分的遍历
     *  将第一个元素设为轴心点
     *    存储指数 = 轴心点指数 +1
     *    从 i=轴心点指数 +1 到 最右指数 的遍历
     *      如果 元素[i] < 元素[轴心点]
     *        交换(i, 存储指数); 存储指数++
     *    交换(轴心点, 存储指数 - 1)
     * @param arr
     */
    private static void quicksort(int[] arr,int l) {
        if(l >= arr.length) return;//递归出口
        int j = l + 1;//l 作为轴心点 j 作为存储指数
        for (int i = l; i < arr.length; i++) {
            if(j >= arr.length) break;//越界情况
            if(arr[i] < arr[j]){
                swap(arr, i, j);
            }
            j++;
        }
        if(j <= arr.length) swap(arr, l, j-1);
        quicksort(arr, ++l);
    }
    /**
     * 交换数组中的两个元素
     * @param arr
     * @param a
     * @param b
     */
    private static void swap(int[] arr,int a,int b){
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

输出

1 6 7 9 13 16 22 26 28 31 45 46 46 49

Gif Power By https://visualgo.net (opens new window)