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

大概意思是：

123的全排列按字典顺序为：

    123 132 213 231 312 321

    如果输入其中某一个序列，返回它的下一个序列。如：输入：213 输出：231 ；输入：321 输出：123

数学推导：

下面归纳分析该过程。假设一个有m个元素的序列p_n，其下一个较大序列为p_n+1。

1) 若p_n最右端的2个元素构成一个增序子序列，那么直接反转这2个元素使该子序列成为减序，即可得到p_n+1。

2) 若p_n最右端一共有连续的s个元素构成一个减序子序列，令i = m - s，则有p_n(i) < p_n(i+1)，其中p_n(i)表示排列p_n的第i个元素。例如p_n=<1 2 5 4 3>，那么p_n的右端最多有3个元素构成一个减序子集<5 4 3>，i=5-3=2，则有p_n(i)=2 < 5=p_n(i+1)。因此若将p_n(i)和其右边的子集s {p_n(i+1), p_n(i+2), ..., p_n(m)}中任意一个元素调换必能得到一个较大的序列（不一定是下一个）。要保证是下一个较大的序列，必须保持p_n(i)左边的元素不动，并在子集s {p_n(i+1), p_n(i+2), ..., p_n(m)}中找出所有比p_n(i)大的元素中最小的一个p_n(j)，即不存在p_n(k) ∈ s且p_n(i) < p_n(k) < p_n(j)，然后将二者调换位置。现在只要使新子集{p_n(i+1), p_n(i+2), ..., p_n(i), ...,p_n(m)}成为最小序列即得到p_n+1。注意到新子集仍保持减序，那么此时直接将其反转即可得到p_n+1 {p_n(1), p_n(2), ..., p_n(j), p_n(m), p_n(m-1), ..., p_n(i), ..., p_n(i+2), p_n(i+1)}。

    

算法思想：举例如下

    输入：1 4 6 5 3 2

    step1：从右往左找到第一个破坏升序(非严格)的元素，此例中为4.记下标为 i

    step2: 依然从右往左,找到第一个大于4的元素，此例中5，交换4和5.

    step3：从i+1到最右端，逆置。6 4 3 2 to 2 3 4 6

    1 5 2 3 4 6 即为所求。

public class Solution {
    public void nextPermutation(int[] nums) {
       	if (nums.length == 0) {
			return ;
		}
	 int i = nums.length-1;
	 int j ;
	//1.从右向左找到第一个破坏升序排列的元素,找到其下标，下标为i-1.
	 while (i > 0 && nums[i] <= nums[i-1]) {
		i--;
	}
	 if (i != 0) {
		j = nums.length - 1;
		//2.依然从右往左,找到第一个大于nums[i-1]的元素，交换这两个元素.
		while (nums[j] <= nums[i-1]) {
			j--;
		}
		swap(nums,j,i-1);
	}
	 j = nums.length-1;
	while (i< j){	
		swap(nums, i,j);		
		i++; j--;		
		}
    }
   public void swap(int[] nums,int i, int j) {
		int temp = nums[i];
		nums[i] = nums[j];
		nums[j] = temp;
	}
}

这个题其实明白其中的原理就不难，自己做的时候找第一个破坏升序元素那的下标总是发蒙，应该多熟练下，

下面是leetcode上参考的答案，写的比我的看着舒服些。

public class Solution {
    public void nextPermutation(int[] nums) {
        int i = nums.length - 2;
        while (i >= 0 && nums[i + 1] <= nums[i]) {
            i--;
        }
        if (i >= 0) {
            int j = nums.length - 1;
            while (j >= 0 && nums[j] <= nums[i]) {
                j--;
            }
            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;
    }
}