Next Permutation

Implement next permutation, which rearranges numbers into the lexicographically next greater permutation of numbers.

If such arrangement is not possible, it must rearrange it as the lowest possible order (ie, sorted in ascending order).

The replacement must be in-place and use only constant extra memory.

Here are some examples. Inputs are in the left-hand column and its corresponding outputs are in the right-hand column.

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

 

解法：

1、从后往前搜索出第一个非递增的值

2、从这个值开始再往后搜索出最后一个比它大的最小的值，交换位置

3、最后将剩余的序列倒序

class Solution {
    public void nextPermutation(int[] nums) {
        //先从后搜索比它大的数，找到的话把它和比它大的最小的数交换
        //如果找不到，整个数组翻转
        //从最后一个数到找到的数翻转
        int len = nums.length;
        int last = -1;
        for(int i=len-1; i>=1; i--){
            if(nums[i]>nums[i-1]){
                last = i-1;
                break;
            }
        }
        
        //判断last的情况
        if(last == -1){
            reverse(nums,0,len-1); 
        }else{
            //找最小
            int min = Integer.MAX_VALUE;
            int pivot = last+1;
            for(int i=last+1;i<len;i++){
                if(nums[i]<=min && nums[i]>nums[last]){ //nums[i]<=min 确保找到最后一个比它大的最小的值
                    min = nums[i];
                    pivot = i;
                }
            }
            int begin = last+1;
            int tmp = nums[pivot];
            nums[pivot] = nums[last];
            nums[last] = tmp;
            reverse(nums,begin,len-1);
        }
        
    }
    
    public void reverse(int[] nums,int left,int right){
        while(left<right){
            int tmp = nums[left];
            nums[left] = nums[right];
            nums[right] = tmp;
            left++;
            right--;
        }
    }
}