(纯白话算法系列)快速排序以及随机快排，时间复杂度分析、代码演示

快速排序（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才能彻底搞懂哦！