codetop7|912. 排序数组（普通快排会超时）

912. 排序数组
     结合官方的动态图理解

class Solution {
    public int[] sortArray(int[] nums) {
        randomizedOuicksort(nums,0,nums.length-1);
        return nums;
    }
    public void randomizedOuicksort(int[] nums,int left,int right){
        if(left<right){
            //随机选一个作为主元,并将主元与数组这一部分的最后一个元素交换，返回这部分快排结束的结果
            int pos=randomizedPartition(nums,left,right);
            //对主元左边进行快排
            randomizedOuicksort(nums, left, pos - 1);
            //对主元右边进行快排
            randomizedOuicksort(nums, pos + 1,right);
        }
    }
    public int randomizedPartition(int[] nums,int left,int right){
        //随机选一个下标所在的值（rand）作为主元
        int rand=new Random().nextInt(right-left+1)+left;
        //将主元与数组这一部分的最后一个元素交换
        swap(nums,right,rand);
        //返回这部分快排结束后的主元素的位置，因为需要再细分主元素左右两组再进行快排 
        //注意 left，right在这里都是下标与是否是主元素无关
        return sort(nums,left,right);
    }
    public int sort(int[] nums,int left,int right){
        //right 此时因为经过交换就是主元
        int pivot=nums[right];
        //一个左指针
        int i=left-1;
        //遍历除主元以外的元素 j相当于一个右指针
        for(int j=left;j<=right-1;j++){
            //如遇到当前遍历元素小于等于主元
            if (nums[j] <= pivot) {
                //只有在遇到比主元小的值这个右指针才会向前移动一次，所以这个左指针永远指向的是排序时比主元素小的最后一个元素
                i=i+1;
                //将左右指针指向的值进行交换
                swap(nums,i,j);
            }
        }
        //将主元素与i（指向比主元素小的值的最后一个值）的下一个值（i+1）进行交换
        swap(nums,i+1,right);
        //现在i+1是主元素
        return i+1;
    }
    private void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }

}

快排的优化：https://leetcode.cn/problems/sort-an-array/solution/kuai-su-pai-xu-you-hua-zhen-dui-duo-zhon-ryq4/

class Solution {

    private static final Random random = new Random();

    public int[] sortArray(int[] nums) {
        quickSort(nums, 0, nums.length - 1);
        return nums;
    }

    private void quickSort(int[] nums, int left, int right) {
        //递归退出条件
        if (left >= right) {
            return;
        }
        //随机选取法
        int RandomIndex = left + random.nextInt(right - left + 1);
        swap(nums, left, RandomIndex);


        //这个是每次把主元素放在最左边了
        int pivot = nums[left];
        int less = left;
        int more = right + 1;
        // 循环不变量：这里是左闭右闭区间
        // 小于nums[pivot]区间：[left + 1, less]
        // 等于nums[pivot]区间：[less + 1, i]
        // 大于nums[pivot]区间：[more, right]
        int i = left + 1;
        while (i < more) {
            if (nums[i] < pivot) {
                //如2451 left指向2 先让left指向4 再将1与4交换
                less++;
                swap(nums, i, less);
                //指向1的下一个值
                i++;
            } else if (nums[i] == pivot) {
                //如24511 则不移动 指向大小顶端的 less more指针 只是移动i来做基础遍历
                i++;
            } else {
                //当nums[i] > pivot
                //这里不i++很重要！因为我们无法确定从尾部换来的元素是否小于nums[pivot]
                more--;
                swap(nums, i, more);
            }
        }
        //less最后指向的一定是小于nums[pivot]的元素
        swap(nums, left, less);
        //同理more指向大于nums[pivot]的元素
        quickSort(nums, left, less - 1);
        quickSort(nums, more, right);
    }


    private void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}