Leetcode_31_下一个排列_思维

首先从后往前找一个数a比它后面一个数要小
这个数a我们把它往后面放，必然可以让整个nums变小
我们用这个数a与这个数a之后一个正好大于它的数b
（我们可以直接从后开始遍历找，甚至可以用二分查找来加速【我懒得这么写】，因为后面的数组一定是单调的）
找到这第二个数b以后，我们交换ab二者的位置，
这就使得整个数变大了，
为了让b后面的数尽可能小，再排个序就完事了。
（其实只要反转就可以了，因为后面的数组是单调递减的）

class Solution {
    public void nextPermutation(int[] nums) {
        int first = -1;
        int len = nums.length;
        for (int i = len - 1; i > 0; i--) {
            if (nums[i - 1] < nums[i]) {
                first = i - 1;
                break;
            }
        }
        if (first == -1) {
            Arrays.sort(nums);
            return;
        }
        int second = first;
        for (int i = len - 1; i > first; i--) {
            if (nums[i] > nums[first]) {
                second = i;
                break;
            }
        }
        nums[first] += nums[second];
        nums[second] = nums[first] - nums[second];
        nums[first] -= nums[second];
        Arrays.sort(nums, first + 1, len);
    }
}

翻转优化完速度也没快多少其实。

class Solution {
    public void nextPermutation(int[] nums) {
        int first = -1;
        int len = nums.length;
        for (int i = len - 1; i > 0; i--) {
            if (nums[i - 1] < nums[i]) {
                first = i - 1;
                break;
            }
        }
        if (first == -1) {
            Arrays.sort(nums);
            return;
        }
        int second = first;
        for (int i = len - 1; i > first; i--) {
            if (nums[i] > nums[first]) {
                second = i;
                break;
            }
        }
        swap(nums,first,second);
        reverse(nums, first + 1);
    }
    public void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
    public void reverse(int[] nums, int start) {
        int left = start, right = nums.length - 1;
        while (left < right) {
            swap(nums, left, right);
            left++;
            right--;
        }
    }
}