Leetcode 31. 下一个排列

题目

实现获取下一个排列的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。

如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。

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

以下是一些例子，输入位于左侧列，其相应输出位于右侧列。

1,2,3 → 1,3,2
3,2,1 → 1,2,3
1,1,5 → 1,5,1

解答

首先必须明确三点：

1. 倒序有序的数是没有下一个排列数的 。
   例如：4，3，2，1 是没有下一个更大的排序数的。
2. 如果打破第一条，那就达到了一个临界点。必然有下一个排序数。那么就让当前位置变大。但增大的幅度要最小。
   例如：1，2，4，3，3， 1 -> 1，3，4，3， 2，1
3. 同样的组成元素，高位变大的数字，无论后几位再小，也比原来的数大。
   例如：1，2，4，3，1 -> 1，3，4，2，1 。可以看出，以1，3开头的新数无论删除线内的3个数字怎么排列，都比前面的大。

明确了以上三点，就可以说一说思路了。
首先，根据第一条规则，写出第一层for循环，倒着循环就好了。一直找到第一个打破倒序有序的位置（以下称当前位置）。
那么现在必然是有下一个排序数了。怎么找下一个排序数呢？
只需要两步：
一：找到让当前位置增大的幅度最小的数字。不理解的话可以看上面第二条规则与示例。
二：根据第三条规则。既然是要找下一个排列数，那么后一部分的数字必然是要最小了。对当前位置后面所有元素升序排列一下即可。

代码一：

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

        Arrays.sort(nums);
    }
}

这样有什么问题呢？
可以知道，在当前位置之后的部分是倒序有序的，既然这样，那能不能使用二分法呢 ！

代码二：

class Solution {
    public void nextPermutation(int[] nums) {
        for (int i = nums.length - 2; i >= 0; i --) {
            if (nums[i] < nums[i + 1]) {
                int index = binarySearch(nums, i + 1, nums.length, nums[i]);
                int t = nums[i];
                nums[i] = nums[index];
                nums[index] = t;
                Arrays.sort(nums, i + 1, nums.length);
                return;
            }
        }

        Arrays.sort(nums);
    }
    
    private int binarySearch(int[] nums, int start, int end, int val) {
        int l = start;
        int r = end - 1;
        int res = start;
        while(l <= r) {
            int mid = ((r - l) >> 1) + l;
            if(nums[mid] > val) {
                res = mid;
                l = mid + 1; 
            } else {
                r = mid - 1;
            }
        }
        
        return res;
    }
}

现在没问题了？不存在的。。。当前位置后面的部分需要排序吗？
不需要，因为后面的部分是倒序有序的。那么只需要使用双指针倒序交换一下就好了。完全不需要排序。

最终代码：

class Solution {
    public void nextPermutation(int[] nums) {
        for (int i = nums.length - 2; i >= 0; i --) {
            if (nums[i] < nums[i + 1]) {
                int index = binarySearch(nums, i + 1, nums.length, nums[i]);
                swap(nums, i, index);
                reverse(nums, i + 1, nums.length);
                return;
            }
        }

        reverse(nums, 0, nums.length);
    }
    
    private int binarySearch(int[] nums, int start, int end, int val) {
        int l = start;
        int r = end - 1;
        int res = start;
        while(l <= r) {
            int mid = ((r - l) >> 1) + l;
            if(nums[mid] > val) {
                res = mid;
                l = mid + 1; 
            } else {
                r = mid - 1;
            }
        }
        
        return res;
    }
    
    private void swap(int[] nums, int i, int j) {
        int t = nums[i];
        nums[i] = nums[j];
        nums[j] = t;
    }
    
    private void reverse(int[] nums, int start, int end) {
        for(int i = start, j = end - 1; i <= j; i ++, j --) {
            swap(nums, i, j);
        }
    }
   
}

结果：