排序算法-快速排序（Java）

package com.rao.sort;

import java.util.Arrays;

/**
 * @author Srao
 * @className QuickSort
 * @date 2019/12/9 14:13
 * @package com.rao.sort
 * @Description
 */
public class QuickSort {

    /**
     * 把数组从中间分开，左边的数都小于pivot，右边的数都大于pivot
     * @param arr：要拆分的数组
     * @param left：从left开始计算
     * @param right：到right截至
     * @return 返回中间值的下标
     */
    public static int partition(int[] arr, int left, int right){
        //把数组中的第一个数当作pivot
        int pivot = arr[left];
        //左指针指向pivot右边的第一个数
        int i = left+1;
        //指向数组末尾最后一个数
        int j = right;
        while (true){
            //从左边开始，找到第一个比pivot大的数
            while (i <= j && arr[i] <= pivot){
                i++;
            }
            //从右边开始，找到第一个比pivot小的数
            while (i <= j && arr[j] >= pivot){
                j--;
            }
            if (i >= j){
                break;
            }
            //交换上面两个数
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        //把pivot交换到数组中间，此时数组大致有序，以pivot为界限，左边的数都比pivot小，右边的数都比pivot大
        arr[left] = arr[j];
        arr[j] = pivot;
        return j;
    }

    /**
     * 快速排序
     * @param arr
     * @param left
     * @param right
     */
    public static void quickSort(int[] arr, int left, int right){
        //用来保存pivot的下标
        int center;
        if (left < right){
            center = partition(arr, left, right);
            quickSort(arr, left, center-1);
            quickSort(arr, center+1, right);
        }
    }

    public static void main(String[] args) {
        int[] arr = {3, 6, 9, 5, 0};
        System.out.println(Arrays.toString(arr));
        quickSort(arr, 0, arr.length-1);
        System.out.println(Arrays.toString(arr));

    }
}

快速排序和归并排序都是采用分治的思想，对数组进行拆分排序，但是快速排序再开辟一个新的数组保存数据，比归并排序节省空间，两个排序的平均时间复杂度都为O(nlogn)

来源：https://www.cnblogs.com/rao11/p/12010852.html