全排列中下一个序列 Next Permutation

为什么80%的码农都做不了架构师？>>>   

问题：
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},较小的数字较先,

这样按字典序生成的全排列是:123,132,213,231,312,321。

① 参考http://www.cnblogs.com/grandyang/p/4428207.html找到的思路，感觉是经验题。

这道题让我们求下一个排列顺序，由题目中给的例子可以看出来，如果给定数组是降序，则说明是全排列的最后一种情况，则下一个排列就是最初始情况。我们再来看下面一个例子，有如下的一个数组

1　　2　　7　　4　　3　　1

下一个排列为：

1　　3　　1　　2　　4　　7

那么是如何得到的呢，我们通过观察原数组可以发现，如果从末尾往前看，数字逐渐变大，到了2时才减小的，然后我们再从后往前找第一个比2大的数字，是3，那么我们交换2和3，再把此时3后面的所有数字转置一下即可，步骤如下：

1　　2　　7　　4　　3　　1 ----- 找到第一个降序的位置

1　　2　　7　　4　　3　　1 ----- 找到其右侧开始找第一个大于它的值

1　　3　　7　　4　　2　　1 ----- 交换这两个值

1　　3　　1　　2　　4　　7 ----- 因为开头变了，反转之后的排列

以上方法中，最坏情况需要扫描数组三次，所以时间复杂度是O(3*n)=O(n)，空间复杂度是O(1)。

class Solution { //18ms
    public void nextPermutation(int[] nums) {
        if(nums == null || nums.length == 0) return;
        int i = nums.length - 2;
        while(i >= 0 && nums[i] >= nums[i + 1]) i --;//找到第一个降序的位置
        if(i >= 0){
            int j = i + 1;
            while(j < nums.length && nums[j] > nums[i]) j ++;
            j --;//找到右侧第一个大于i处值的位置
            swap(nums,i,j); //交换两个值
        }
        reverse(nums,i + 1,nums.length - 1); //将i之后的值反序
    }
    public void swap(int[] nums,int i,int j){
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
    public void reverse(int[] nums,int i,int j){
        while(i < j)
            swap(nums,i ++,j --);
    }
}

② 使用for循环。

class Solution {//17ms
    public static void nextPermutation(int[] nums) {
        if (nums == null || nums.length == 0 || nums.length == 1) return;
        int i;
        for (i = nums.length - 2;i > 0;i --){
            if (nums[i] < nums[i + 1]){
                break;
            }
        }
        if (i == 0 && nums[i] > nums[i + 1]){
            reverse(nums,i,nums.length - 1);
            return;
        }
        int j;
        for (j = i + 1;j < nums.length;j ++){
            if(nums[j] <= nums[i]) break;
        }
        j --;
        swap(nums,i,j);
        reverse(nums,i + 1,nums.length - 1);
    }
    public static void swap(int[] nums,int i,int j){
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
    public static void reverse(int[] nums,int i,int j){
        while(i <= j){
            int tmp = nums[i];
            nums[i] = nums[j];
            nums[j] = tmp;
            i ++;
            j --;
        }
    }
}

转载于:https://my.oschina.net/liyurong/blog/1527913