31. Next Permutation [Medium]

/**
 * 自己的代码
 * Runtime: 1 ms, faster than 30.69%
 * Memory Usage: 38.7 MB, less than 94.78%
 */
class Solution {
    public void nextPermutation(int[] nums) {
        for (int i = nums.length - 1; i >= 1; i--) { // 从后往前遍历nums，找到当前nums中不符合最大字典序的最低位
            // 一直是字典序倒序时，一直continue
            if (nums[i] <= nums[i - 1]) 
                continue;
            // 找到不符合最大字典序的最低位（打破倒序的位置）：i - 1
            int idx = i + 1; // 已确定nums[i] > nums[i - 1]，所以从i + 1位置开始找
            while (idx < nums.length && nums[idx] > nums[i - 1]) // 寻找i - 1位置后面的元素中，大于i - 1位置元素的最小值（循环后得到的idx - 1位置元素）
                idx++;
            swap(nums, i - 1, idx - 1); // 将idx - 1位置元素与i - 1位置元素交换
            Arrays.sort(nums, i, nums.length); // 换好后将i - 1位置之后的数组部分按字典序从小到大排列
            return;
        }
        Arrays.sort(nums); // nums完全按照字典序逆序，没有更大的排列，则按照题意从小到大排列
    }
    private void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

/**
 * 和上面的思路一样，但自己写reverse方法实现反转，比直接用Arrays.sort()排序更快、更符合解题情况
 * 因为每次我们排序，都是将原本是倒序的序列转为正序，因此只需要做反转，不用做排序
 * 将序列的对称位置直接交换，也是缩短循环的技巧
 * Runtime: 0 ms, faster than 100.00%
 * Memory Usage: 38.7 MB, less than 94.78%
 */
class Solution {
    public void nextPermutation(int[] nums) {
        for (int i = nums.length - 1; i >= 1; i--) {
            if (nums[i] > nums[i - 1]) {
                int idx = i + 1;
                while (idx < nums.length && nums[idx] > nums[i - 1])
                    idx++;
                swap(nums, i - 1, idx - 1);
                reverse(nums, i);
                return;
            }
        }
        reverse(nums, 0);
    }
    private void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
    private void reverse(int[] nums, int start) {
        for (int i = start; i < (nums.length + start) / 2; i++)
            swap(nums, i, nums.length - 1 + start - i);
    }
}