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]，但實際上這不是第二大的。
只能先進入下一層，縮小範圍。
第二層

第二層發現第三層返回的是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;
    }
   
        
   
    
    
              
    
}