(純白話算法系列)快速排序以及隨機快排，時間複雜度分析、代碼演示

快速排序（Quicksort）是對冒泡排序的一種改進。

快速排序由C. A. R. Hoare在1960年提出。它的基本思想是：通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然後再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。

本篇部分詞義解釋：

基數：指數組中一個元素，數組中其他元素都和該元素進行比較，小於等於基數的部分放在基數左邊，大於它的部分放在基數的右邊

白話說：

說白了快速排序是有冒泡排序一點思想的，主要排序流程是先以一個數字爲基準，把小於等於它的數全部放在它的左邊，大於它的數全部放在它的右邊，它的位置其實就已經排好了，左右兩部分再分別選出一個數爲基準，分別以小於等於各自基準數的數字全部放在左半部分，大於基準數的數字全部放在右半部分。直接上圖看：

圖片太大了，只能分開上傳。。
新手看這個排序算法會比較費勁，但是沒關係，耐心繼續看完這篇博客並且自己動手敲幾遍，你一定會學會！！！

普通快速排序其實涉及了一種分治的思想，就是每次循環都把小於等於它的放在左邊，大於它的放在右邊。然後小於等於這部分再以這部分的最右邊數字爲基數繼續把小於等於它的放在左邊，大於它的放在右邊，大於部分同樣如此，概略圖如下：

看代碼

package com.bean.com.bean.sortAlg;

import java.util.Arrays;


public class QuickSortDemo{
    public static void QuickSort(int[] arr) {
        if(arr == null || arr.length < 2)
            return;
        QuickSort(arr, 0, arr.length - 1);
    }

    public static void QuickSort(int[] arr, int left, int right) {
        if(left < right) {
        	//隨機快排，下面會說這是什麼
            swap(arr, left + (int)(Math.random() * (right - left + 1)), right);
            int[] p = partition(arr, left, right);
            QuickSort(arr, left, p[0] - 1);
            QuickSort(arr, p[1] + 1, right);
        }
    }
	//返回中間排好序的區間
    public static int[] partition(int[] arr, int left, int right) {
        int less = left - 1;
        int more = right;
        while(left < more) {
            if(arr[left] < arr[right]) {
                swap(arr, ++less, left++);
            }else if(arr[left] > arr[right]) {
                swap(arr, --more, left);
            }else
                left++;
        }
        swap(arr, more, right);
        return new int[]{less + 1, more};
    }
	//交換位置
    public static void swap(int[] arr, int a1, int a2){
        int temp = arr[a1];
        arr[a1] = arr[a2];
        arr[a2] = temp;
    }
	//正確的排序方法
    public static void comparator(int[] arr) {
        Arrays.sort(arr);
    }
	//形成隨機數組
    public static int[] generateRandomArray(int maxSize, int maxNum) {
        int[] arr = new int[(int)(Math.random() * maxSize + 1)];
        for(int i = 0; i < arr.length; i++) {
            arr[i] = (int)(Math.random() * maxNum+1) - (int)(Math.random());
        }
        return arr;
    }
	//複製數組
    public static int[] copyArray(int[] arr) {
        if (arr == null) {
            return null;
        }
        int[] res = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            res[i] = arr[i];
        }
        return res;
    }
	//判斷兩個數組是否相同
    public static boolean isEqual(int[] arr1, int[] arr2) {
        if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
            return false;
        }
        if (arr1 == null && arr2 == null) {
            return true;
        }
        if (arr1.length != arr2.length) {
            return false;
        }
        for (int i = 0; i < arr1.length; i++) {
            if (arr1[i] != arr2[i]) {
                return false;
            }
        }
        return true;
    }
	//打印數組內容
    public static void printArray(int[] arr) {
        if (arr == null) {
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int testTime = 500000;
        int maxSize = 20;
        int maxValue = 100;
        boolean succeed = true;
        for (int i = 0; i < testTime; i++) {
            int[] arr1 = generateRandomArray(maxSize, maxValue);
            int[] arr2 = copyArray(arr1);
            QuickSort(arr1);
            comparator(arr2);
            if (!isEqual(arr1, arr2)) {
                succeed = false;
                printArray(arr1);
                printArray(arr2);
                break;
            }
        }
        System.out.println(succeed ? "成功!" : "有錯。。");

        int[] arr = generateRandomArray(maxSize, maxValue);
        printArray(arr);
        QuickSort(arr);
        printArray(arr);

    }
}

加了swap(arr, left + (int)(Math.random() * (right - left + 1)), right);這句話就是隨機快排爲什麼？

我們先分析一下普通快速排序的時間複雜度，很簡單，因爲用到了分治思想，所以T(n) = 2T(N/2) + O(n)，不知道這是什麼意思請點擊這裏，所以時間複雜度爲N*logN，可是仔細想一下，如果順序爲1 2 3 4 5 6 7，那豈不是每次都需要變換位置，跟冒泡排序不就完全一樣了，絲毫沒有增加效率，時間複雜度爲O(N²)，爲了避免這種分區域太極限了，所以我們不每次只跟數組的最後一個元素進行比較，而是從數組中隨機選一個元素爲基數。所以隨機快排的時間複雜度就是一個概率事件了，它的數學期望是NlogN，算法上比普通快排更優。

理解原理後動手多敲幾遍，多跟幾遍debug才能徹底搞懂哦！