java算法-快速排序

一、思想

该算法在数组中选择一个主元将数组一分为二。使得第一部分中的元素都小于或等于主元，第二部分中的元素都大于主元。然后对第一部分递归应用快速排序算法，对第二部分递归的应用快速排序算法。不过快速排序每次划分都将主元放在了恰当的位置，因为主元的选择直接影响了算法的性能。在理想的情况下，应该选择能平均划分两部分的主元。

二、图解

三、代码实现

 public static void quickSort(int[] arr,int low,int high){
        int i,j,temp,t;
        if(low>high){
            return;
        }
        i=low;
        j=high;
        //temp就是基准位
        temp = arr[low];

        while (i<j) {
            //先看右边，依次往左递减
            while (temp<=arr[j]&&i<j) {
                j--;
            }
            //再看左边，依次往右递增
            while (temp>=arr[i]&&i<j) {
                i++;
            }
            //如果满足条件则交换
            if (i<j) {
                t = arr[j];
                arr[j] = arr[i];
                arr[i] = t;
            }

        }
        //最后将基准为与i和j相等位置的数字交换
        arr[low] = arr[i];
        arr[i] = temp;
        //递归调用左半数组
        quickSort(arr, low, j-1);
        //递归调用右半数组
        quickSort(arr, j+1, high);
    }

时间复杂度O(nlogn)~O(n方)
最差情况：当数组原本就按从小到大顺序排列时：
10 20 30 40 50 60 70 80 第一轮比较，将10分别与20、30、...、80比较，共比较n-1次
第二轮比较，将20分别与30、...、80比较，共比较n-2次
....
共比较(n-1)+(n-2)+...+1次，即时间复杂度为O(n方)，与冒泡排序时间复杂度一样

一般情况：时间复杂度为O(nlogn) 需要复杂的数学证明

空间复杂度O(logn)~O(n)
真正消耗空间的就是递归调用了，因为每次递归就要保持一些数据；
最优的情况下空间复杂度为：O(logn)  ；每一次都平分数组的情况
最差的情况下空间复杂度为：O( n )   ；退化为冒泡排序的情况