經驗證，快速排序是速度最快的排序方式！比冒泡快的不是一點點！

/**氣泡排序
     * 比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。  
     * 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。  
     * 針對所有的元素重複以上的步驟，除了最後一個。
     * 持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。 
*/

快速排序的基本思想：

         通過一趟排序將待排序記錄分割成獨立的兩部分，其中一部分記錄的關鍵字均比另一部分關鍵字小，則分別對這兩部分繼續進行排序，直到整個序列有序。

升序排列：

package com.hczk.controller;

import java.util.Arrays;

/**
 * Created by Administrator on 2018/12/11 0011.
 */

public class QuickSort {

    public static void main(String args[]) {
        int[] arrays ={1, 12, 2, 13, 3, -14, 4, 15, 5, 16, 17, 17, 177, 18, 8, 8, 19};
        System.out.println(Arrays.toString(subQuickSort(arrays, 0, arrays.length - 1)));
    }


    public static int[] subQuickSort(int[] arrays, int start, int end) {
        if (start < end) {
            int middleIndex = subQuickSortCore(arrays, start, end);//將numbers陣列進行一分為二
            subQuickSort(arrays, start, middleIndex - 1);//對低欄位表進行遞迴排序
            subQuickSort(arrays, middleIndex + 1, end);//對高欄位表進行遞迴排序
        }
        return arrays;
    }

    public static int subQuickSortCore(int[] arrays, int start, int end) {
        int middleValue = arrays[start];
        while (start < end) {
            while (arrays[end] >= middleValue && start < end) {//
                end--;
            }
            arrays[start] = arrays[end];
            while (arrays[start] <= middleValue && start < end) {//
                start++;
            }
            arrays[end] = arrays[start];
        }
        arrays[start] = middleValue;
        return start;
    }

}

 

把整個序列看做一個數組，把第零個位置看做中軸，和最後一個比，如果比它小交換，比它大不做任何處理；交換了以後再和小的那端比，比它小不交換，比他大交換。這樣迴圈往復，一趟排序完成，左邊就是比中軸小的，右邊就是比中軸大的，然後再用分治法，分別對這兩個獨立的陣列進行排序。

package com.hczk.controller;

import java.util.Arrays;

/**
 * Created by Administrator on 2018/12/11 0011.
 */

public class QuickSort {

    public static void main(String args[]) {

        int[] arrays ={1, 12, 2, 13, 3, -14, 4, 15, 5, 16, 17, 17, 177, 18, 8, 8, 19};
        System.out.println(Arrays.toString(subQuickSort(arrays, 0, arrays.length - 1)));
    }


    public static int[] subQuickSort(int[] arrays, int start, int end) {
        if (start < end) {
            int middleIndex = subQuickSortCore(arrays, start, end);//將numbers陣列進行一分為二
            subQuickSort(arrays, start, middleIndex - 1);//對低欄位表進行遞迴排序
            subQuickSort(arrays, middleIndex + 1, end);//對高欄位表進行遞迴排序
        }
        return arrays;
    }

    public static int subQuickSortCore(int[] arrays, int start, int end) {
        int middleValue = arrays[start];
        while (start < end) {
            while (arrays[end] <= middleValue && start < end) {//
                end--;
            }
            arrays[start] = arrays[end];
            while (arrays[start] >= middleValue && start < end) {//
                start++;
            }
            arrays[end] = arrays[start];
        }
        arrays[start] = middleValue;
        return start;
    }

}

 

降序 

時代不斷進步！主要提倡上面的方式，下面的只做參考

package com.hczk.controller;

import java.util.Arrays;

/**
 * Created by Administrator on 2018/12/11 0011.
 */

public class QuickSort {

    public static void main(String[] args) {
        int[] arr = {60, 55, 48, 37, 10, 90, -84, 36};
        System.out.println("升序快排後----->" + Arrays.toString(quickSort(arr, 0, arr.length - 1)));
    }

    public static int[] quickSort(int[] arr, int low, int high) {

        int i, j, temp;
        i = low;//低端下標
        j = high;//高階下標
        temp = arr[i];//取第一個元素為標準元素。

        while (i < j) {//遞迴出口是 low>=high

            while (i < j && temp <= arr[j]) //在陣列的後端掃描
                j--;//移動後j再減了一個，即在temp前一個咯
            if (i < j) {
                arr[i] = arr[j];
                i++;
            }

            while (i < j && arr[i] < temp) //在陣列的左端掃描
                i++;
            if (i < j) {
                arr[j] = arr[i];
                j--;
            }

        }//while完，即第一盤排序
        arr[i] = temp;//把temp值放到它該在的位置
//		 System.out.println("第    次排序----->"+Arrays.toString(arr));
        if (low < i) {
            quickSort(arr, low, i - 1);//對左端子陣列遞迴
        }

        if (i < high) {
            quickSort(arr, j + 1, high);//對右端子陣列遞迴
        }

        return arr;
    }

}

相比於上面一個，似乎做了一點改變。

package com.hczk.controller;

import java.util.Arrays;

/**
 * Created by Administrator on 2018/12/11 0011.
 */

public class QuickSort {

    public static void main(String[] args) {
        int[] arr = {60, 55, 48, 37, 10, 90, -84, 36};
        System.out.println("降序快排後----->" + Arrays.toString(quickSort(arr, 0, arr.length - 1)));
    }


    public static int[] quickSort(int[] arr, int high, int low) {
        int i, j, temp;
        i = high;//高階下標
        j = low;//低端下標
        temp = arr[i];//取第一個元素為標準元素。

        while (i < j) {//遞迴出口是 low>=high
            while (i < j && temp > arr[j])//後端比temp小，符合降序，不管它，low下標前移
                j--;//while完後指比temp大的那個
            if (i < j) {
                arr[i] = arr[j];
                i++;
            }
            while (i < j && temp < arr[i])
                i++;
            if (i < j) {
                arr[j] = arr[i];
                j--;
            }
        }//while完，即第一盤排序
        arr[i] = temp;//把temp值放到它該在的位置。

        if (high < i) {//注意，下標值
            quickSort(arr, high, i - 1);//對左端子陣列遞迴
        }

        if (i < low) { //注意，下標值
            quickSort(arr, i + 1, low);//對右端子陣列遞迴  ；對比上面例子，其實此時i和j是同一下標!!!!!!!!!!!!!
        }


        return arr;
    }


}

降序排列