（容易理解版）快速排序算法和时间、空间复杂度的计算

public class QuickSort {
    /**
     * 快速排序
     * @param args
     */
    public static void main(String[] args) {
        int[] arr = {10,7,2,4,7,62,3,4,2,1,8,9,19};
        quickSort(arr, 0, arr.length-1);
        System.out.println(Arrays.toString(arr));

    }

    public static void quickSort(int[] arr,int left,int right){
        int i,j,standard;
        //left与right固定不变，通过改变i、j进行指针的移动
        i = left;
        j= right;
        //迭代退出的条件
        if(i>=j){
            return;
        }
        standard = arr[left];
        while(i<j){
            //以左起点为基准值，要先移动右指针，否则可能会出现基准值与j位置的值交换后，j左侧的数组值不满足都小于j位置的值
            while(standard<=arr[j] && i<j){
                j--;
            }
            while(standard>=arr[i] && i<j){
                i++;
            }
            if(i<j){
                arr[j] = arr[j]^arr[i];
                arr[i] = arr[i]^arr[j];
                arr[j] = arr[j]^arr[i];
            }
        }
        //令数组中基准值与下标为j的值进行交换，使得j左边小于j位置的值，j左右边大于j位置的值
        arr[left] = arr[j];
        arr[j] = standard;
        quickSort(arr,left,j-1);
        quickSort(arr,j+1,right);
    }
}

快速排序时间复杂度的计算：

设n=2^k，这是为了最后能得到T(1)，T(1)=0
T(n)=2T(n/2)+n
      =2(2T(n/4)+n/2)+n
      =4T(n/4)+2n
      =4(2T(n/8)+n/4)+2n
      =8T(n/8)+3n
      =......
　  =2^kT(1)+kn    将n=2^k代入
     =n(T(1)+log2n)  将T(1)=0代入
     =nlog2n
     =o(nlogn)
所以快速排序的时间复杂度是o(nlogn)

快速排序空间复杂度计算：

迭代空间复杂度=迭代深度*每次迭代的空间复杂度。

深度          1  2  3  4  ...  k
调用次数   1  2  4  8  ...  2^(k-1)

假设有1个数据就要调用1次，则n个数据要调用2^(k-1)次，但是有1个数据时不需要调用，所以n<2^(k-1)，此处的n是调用n次的n，则k>logn+1,所以迭代的空间复杂度大于o(logn).
若数据是按顺序排列的，一共需要调用n-1次，则最大空间复杂度为o(n).

快速排序的空间复杂度在o(logn)~o(n)之间。