31.下一个排序

整数数组的一个 排列  就是将其所有成员以序列或线性顺序排列。

• 例如，arr = [1,2,3] ，以下这些都可以视作 arr 的排列：[1,2,3]、[1,3,2]、[3,1,2]、[2,3,1] 。

整数数组的 下一个排列 是指其整数的下一个字典序更大的排列。更正式地，如果数组的所有排列根据其字典顺序从小到大排列在一个容器中，那么数组的 下一个排列 就是在这个有序容器中排在它后面的那个排列。如果不存在下一个更大的排列，那么这个数组必须重排为字典序最小的排列（即，其元素按升序排列）。

• 例如，arr = [1,2,3] 的下一个排列是 [1,3,2] 。
• 类似地，arr = [2,3,1] 的下一个排列是 [3,1,2] 。
• 而 arr = [3,2,1] 的下一个排列是 [1,2,3] ，因为 [3,2,1] 不存在一个字典序更大的排列。

给你一个整数数组 nums ，找出 nums 的下一个排列。

必须 原地 修改，只允许使用额外常数空间。

复杂度分析：一个for循环找到数字A，再一个for循环找到数字C，反转reverse 双指针。

复杂度：n 1

public void nextPermutation(int[] nums){
    int len = nums.length;
    
    // 思路：
    // 1、从后向前找到，直到找到数字A，它的前面数字B，满足B<A。
    // 2、从B之后的数组部分，找到数字C，满足：C = min(B之后的数组部分中满足>B的数)
    // 3、交换BC的值，再将C（交换后的，即交换前B的位置）位置之后的数组反转
    for(int i = len-1; i > 0; i--){
        if(nums[i] > nums[i-1]){
            int idx = returnIdxOfNumberC(nums, i-1);
            swap(nums, idx, i-1);
            reverse(nums, i);
            return;
        }
        // 特判。对于是最大排序的直接返回其反转数组。
        if(i == 1){
            reverse(nums, 0);
            return;
        }
    }
    
}

// 返回数字C的index
public int returnIdxOfNumberC(int[] nums, int i){
    int min = Integer.MAX_VALUE;
    int idx = -1;
    for(int j = i; j < nums.length; j++){
        if(nums[j] > nums[i] && nums[j] < min){
            min = nums[j];
            idx = j;
        }
    }
    return idx == -1 ? nums.length-1 : idx;
}

public void reverse(int[] nums, int start){
    int l = strat, r = nums.length-1;
    while(l < r){
        swap(nums, l, r);
        l++;
        r--;
    }
}

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

lc

class Solution {
    public void nextPermutation(int[] nums) {
       // 用给出的数字组成一个，比当前的数字刚好再大一点的数
        int len = nums.length;
        
        // // 对最后一个排序特判。
        // // 思路：如果当前排序是递减的，则是最后一个排序。
        // // 返回从小到大的排序即可。(反转 reverse可以将时间复杂度从nlogn降到n)
        // boolean flag = true;
        // for(int i = 0; i < len - 1; i++){
        //     if(nums[i] < nums[i+1]) {
        //         flag = false;
        //         break;
        //     }
        // }
        // if(flag){
        //     // Arrays.sort(nums);
        //     reverse(nums, 0);
        //     return;
        // } 

        // 从后向前,找到最大的一位数A，数字A前一位即为一个将要交换的数B。再找数字B之后比B大的最小的数字C，
        // 交换BC。交换完成后，对原先B位置之后的数组进行排序
        //（可以直接反转reverse，因为这部分的数组满足从大到小排序。降低时间复杂度）。   
        for(int i = len - 1; i > 0; i--){
            if(nums[i] > nums[i-1]) {
                int temp = nums[i-1]; // B
                int idx = returnThanCurMaxALitter(nums, i-1);
                nums[i-1] = nums[idx];
                nums[idx] = temp;
                Arrays.sort(nums, i, len);
                // reverse(nums, i);
                break;
            }
            // 对最后一个排序特判。
            if(i == 1) {
                reverse(nums, 0);
                return;
            }
        }
    }

    // 找数字B之后比B大的最小的数字C的下标，并返回。
    public int returnThanCurMaxALitter(int[] nums, int cur_i){
        int min = Integer.MAX_VALUE;
        int idx = -1;
        for(int i = cur_i+1; i < nums.length; i++){
            if(nums[cur_i] < nums[i] && min >= nums[i]) {
                min = nums[i];
                idx = i;
            }
        }
        return idx == -1 ? cur_i+1 : idx;
    }

    public void reverse(int[] nums, int start){
        int l = start, r = nums.length - 1;
        while(l < r){
            int temp = nums[l];
            nums[l++] = nums[r];
            nums[r--] = temp;
        }
    }
}