LeetCode-31. 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, do not allocate 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”的全排列是

1  2  3

1  3  2

2  1  3

2  3  1

3  1  2

3  2  1

题目是要求将数组从某一行重排到下一行，如果当前数组是最后一行，则返回第一行的排列形式。

1.本人的思路是从最后一位开始倒序的比较相邻两个数字的大小，如果发现num[i]>nums[i-1]，则寻找从i到nums.length-1大于nums[i-1]且最接近的数，并将这个数和nums[i-1]交换，然后将数组从i到nums.length-1的数重新按照从小到大排列即可。

三、代码

1.

public class Solution {
    public void nextPermutation(int[] nums) {
        if(nums==null || nums.length<=1)
            return;
        boolean flag=false;
        int point=0;
        for(int i=nums.length-1;i>0;i--){
            if(nums[i]>nums[i-1]){
                flag=true;
                for(int j=nums.length-1;j>i-1;j--){
                    if(nums[j]>nums[i-1]){
                        int temp=nums[i-1];
                        nums[i-1]=nums[j];
                        nums[j]=temp;
                        break;
                    }
                }
                nums=sortAl(nums,i);

		//Arrays.sort(nums,i,nums.length);//当然也可以使用Arrays.sort()对数组进行部分排序
                break;
            }
        }
        if(!flag)
            Arrays.sort(nums);
    }
    public int[] sortAl(int[] nums,int point){
        for(int i=point;i<nums.length-1;i++){
            for(int j=i+1;j<nums.length;j++){
                if(nums[i]>nums[j]){
                    int temp=nums[i];
                    nums[i]=nums[j];
                    nums[j]=temp;
                }
            }
        }
        return nums;
    }
}

2.发现数组从i到nums.length-1的数并不需要重新排序，因为这部分是降序排列的，只要将第一个和最后一个，第二个和倒数第二个交换位置即可，以此类推。

public class Solution {
    public void nextPermutation(int[] nums) {
        if(nums==null || nums.length<=1)
            return;
        boolean flag=false;
        int point=0;
        for(int i=nums.length-1;i>0;i--){
            if(nums[i]>nums[i-1]){
                flag=true;
                for(int j=nums.length-1;j>i-1;j--){
                    if(nums[j]>nums[i-1]){
                        swapNums(nums,i-1,j);
                        break;
                    }
                }
                reverseNums(nums,i,nums.length-1);
                //nums=sortAl(nums,i);
                //Arrays.sort(nums,i,nums.length);
                break;
            }
        }
        if(!flag)
            Arrays.sort(nums);
    }
    private int[] sortAl(int[] nums,int point){
        for(int i=point;i<nums.length-1;i++){
            for(int j=i+1;j<nums.length;j++){
                if(nums[i]>nums[j]){
                    int temp=nums[i];
                    nums[i]=nums[j];
                    nums[j]=temp;
                }
            }
        }
        return nums;
    }
    private void swapNums(int[] nums,int i,int j){
        int temp=nums[i];
        nums[i]=nums[j];
        nums[j]=temp;
        //return nums;
    }
    private void reverseNums(int[] nums,int start,int end){
        for(int i=start;i<=(end+start)/2;i++)
            swapNums(nums,i,start+end-i);
    }
}