[leetcode]31. Next Permutation

Solution 1：自己想的递归

i从最后一个数字往前比较，最远可以和nums[0]比较，直到扫描到nums[i]>nums[j]（如果交换，则数字会变大）
此时进入下一层递归，从最后一个数字开始往前比较，最远可以比较到nums[j+1]
以此类推

如果在每一层递归都没有发现nums[i]>nums[j] ，那么这一层返回false
如果在某一层发现了并且更深一层返回的状态是false，那么交换，返回true给上一层

---

比如输入这个：
[4,1,8,5,9,7,5]
第一层：
i从最后一个5开始往前找，发现5>1,妄图交换变成[4,5,8,5,9,7,1]，但实际上这不是第二大的。
只能先进入下一层，缩小范围。
第二层：
循环减减最多只能找到 上一层妄图交换的后一位（上一层想换1，所以这里只能在最后一个数字到8之前找）
【8,5,9,7,5】发现7＞前面的5，妄图交换，但不知道下一层还有没有更优的解
进入下一层，缩小范围
第三层：
循环减减最多只能找到 上一层妄图交换的后一位（上一层想换5，所以这里只能在最后一个数字到9之前找）
【9,7,5】没有发现有，这一层结束，return false，表示第三层没有比第二层更优的解了

第二层发现第三层返回的是false，且第二层妄图交换，所以此时就找到了。第二层交换后得到【8,7,9,5,5】，然后对交换的数字的后一个数字到最后，进行从小到大排序，得【8,7,5,5,9】。return true

第一层发现第二层return true。就不能在交换了，直接返回[4,1,8,7,5,5,9]。整个结束了。

---

特殊情况：
i一直减到0都没有nums[i]>nums[j]，说明是降序排列的，此时只能变成升序排列
例如[3,2,1]->[1,2,3]

class Solution {
    public void nextPermutation(int[] nums) {
        
       boolean status=next(nums,0);
    }
    
    
    private boolean next(int[] nums,int start){
        
        
        int i=nums.length-1;
        
        for(i=nums.length-1;i>start;i--){
            for(int j=i-1;j>=start;j--){
               
                if(nums[i]>nums[j]){
                    
                    if(next(nums,j+1)==false){
                        
                        int temp=nums[j];
                        nums[j]=nums[i];
                        nums[i]=temp;
                        
                        bubbleSort(nums,j);
                    }
                    
                    return true;
                                  
                }
                        
            }
            
        }
        
        if(i==0){
            for(int k=0;k<nums.length/2;k++){
                int temp=nums[k];
                nums[k]=nums[nums.length-1-k];
                nums[nums.length-1-k]=temp;
            }
        }
        
       return false;
    }
    
    
    private void bubbleSort(int[] nums,int j){
        for(int m=j+1;m<nums.length-1;m++){
            for(int q=j+1;q<nums.length-1;q++){
                if(nums[q]>nums[q+1]){
                    int temp=nums[q];
                    nums[q]=nums[q+1];
                    nums[q+1]=temp;
                }
            }
        }
                   
    } 
}

Solution 2: one pass

官方给的方法

class Solution {
    public void nextPermutation(int[] nums) {
       int i=nums.length-1;
        
        while(i>=1){
            if(nums[i]<=nums[i-1]){
                i--;
            }
            else{
                break;
            }
        }
        i--;
        
        int j=nums.length-1;
        while(j>i&&i>=0){
            if(nums[j]<=nums[i]){
                j--;
            }
            else{
                break;
            }
        }
        
        if(i>=0)
        swap(nums,i,j);
        
        reverse(nums,i+1);
    }
    
    private void reverse(int[] nums, int start) {
        int i = start, j = nums.length - 1;
        while (i < j) {
            swap(nums, i, j);
            i++;
            j--;
        }
    }

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