# quickSort

quickSort 快排

1. 基本描述

​ quickSort 使用分支法策略

​ 稳定性 不稳定

​ 时间复杂度
$$
O(nlog_2n)
$$
​ 空间复杂度
$$
O(n)
$$

​ 转载…这段话

​ 首先就地快速排序使用的空间不是O(1)的，也就是个常数级；而真正消耗空间的就是递归调用了，因为每次递归就要保持一些数据；

​ 最优的情况下空间复杂度为：O(logn) ；每一次都平分数组的情况

​ 最差的情况下空间复杂度为：O( n ) ；退化为冒泡排序的情况

​ 目前水平还不能较好理解。之后填坑

2. 基本思想

1. 从数列中挑出一个基准值 一般选择第一个

2. 将所有比基准值小的放在基准值后面，所有比基准值大的放在基准值后面

3. 递归

   个人觉得比堆排序简单。

3. 代码实现

package swapSort;

public class quicksort {

    private static void quicksort(int[] array, int low, int high) {
        if (high <= low)
            return;   //终止条件

        int i, j, key;
        i = low;
        j = high+1 ;//搭配下面的--j 这样去理解，high 传入的数组坐标，一开始就是length-1
        key = array[low];
        while (true) {
            while (array[++i] < key) {
                if (i == high)
                    break;
            }
            while (array[--j] > key) {
                if (j == low)
                    break;
            }
            if (i >= j) break;

            swap(array, i, j);
        }

        swap(array, low, j);  //最后需要找到合理的key所在的位置
        quicksort(array,low,j-1);
        quicksort(array,j+1,high);
    }

    private static void swap(int[] array, int i, int j) {
        int tmp=array[i];
        array[i]=array[j];
        array[j]=tmp;
    }


    public static void main(String[] args) {
        int[] array = {1, 2, 3, 0, 2, 1, -1, -3};
        quicksort(array, 0, array.length-1);
        for (int i : array
        ) {
            System.out.println(i);
        }
//        System.out.println(array);
    }
}