数据结构与算法-快速排序

1.时间复杂度:nlogn 最坏的情况就是O(n^2)
2.空间复杂度:O(n)
3.稳定性：不稳定
4.快排和归并的对比：
（1）归并排序的处理过程是由下到上的，先处理子问题，然后再合并。
（2）快排其实就是从上到下，先分区，在处理子问题，不用合并。
其优化就是优化基准数,提供一个取三个数中间的思路.

package edu.sort;

import cn.hutool.core.util.ArrayUtil;

/**
 * 快速排序
 * 核心概念：基准数。一般取第一个。
 * 第一遍对比，结果
 * 左边比基准数小，右边比基准数小。
 * 不稳定排序
 * 与归并排序的区别，一个是分完再排，一个是分完排序后再分,不合并
 * 优化：优化基准数
 * 算法复杂度  O(nlogn)
 * 选择算法的方法
 * 1，分析场景，稳定还是不稳定
 * 2，数据量，数据量小的时候选择插入排序，或者快速排序
 * 3，分析空间:
 * 综上所述，都是要根据情况分析的，如果不会分析的情况，选择归并或者快排
 *
 * @author: LHT
 * @date: 2020/12/20 17:13
 */
public class QuickSort {

    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        int a[] = {1, 23, 123, 54234, 121, 1, 231, 45, 1, 23};
        quickSort(a, 0, a.length - 1);
        System.out.println("用时：" + (System.currentTimeMillis() - start));
        System.out.println(ArrayUtil.toString(a));

    }

    public static void quickSort(int array[], int left, int right) {
        //取基准数，取数组的第一个
        int base = array[left];
        int ll = left;
        int rr = right;
        while (ll < rr) {
            //从后往前找比基准数小的数，找到则跳出。
            while (ll < rr && array[rr] >= base) {
                rr--;
            }
            //从后往前找比基准数小的数
            if (ll < rr) {
                switchData(array,rr,ll);
                ll++;
            }
            //从后往前找比基准数大的数，然后交换
            while (ll < rr && array[ll] <= base) {
                ll++;
            }
            System.out.println(ll+":"+rr);
            //如果找到则交换
            if (ll < rr) {
                switchData(array,rr,ll);
                rr--;
            }

        }
        if (left < ll) {
            quickSort(array, left, ll - 1);
        }
        if (rr < right) {
            quickSort(array, ll + 1, right);
        }
    }

    /**
     * 交换顺序
     */
    public static void switchData(int a[], int i, int j) {
        a[j] = a[j] + a[i];
        a[i] = a[j] - a[i];
        a[j] = a[j] - a[i];
    }
}