*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

 

解題思想：

所謂一個排列的下一個排列的意思就是 這一個排列與下一個排列之間沒有其餘的排列。這就要求這一個排列與下一個排列有儘量長的共同前綴，也即變化限制在儘量短的後綴上。可能理解起來比較難懂。

對於數字序列：

先看前面2排的話，能夠看出來第二排是比第一排要大的，參考字符串比較大小的問題。那麼第2個排列是否是第一個排列的下一個排列呢。很明顯不是，第3個排列纔是， 那麼如何獲取到下一個排列呢。步驟比較簡單：假設數組大小爲 n

        1.從後往前，找到第一個 A[i-1] < A[i]的。也就是第一個排列中的  6那個位置，能夠看到A[i]到A[n-1]這些都是單調遞減序列。

        2.從 A[n-1]到A[i]中找到一個比A[i-1]大的值（也就是說在A[n-1]到A[i]的值中找到比A[i-1]大的集合中的最小的一個值）

        3.交換 這兩個值，而且把A[n-1]到A[i]排序，從小到大。

 

 

Supplement:

「這道題是給定一個數組和一個排列，求下一個排列。算法上其實沒有什麼特別的地方，主要的問題是常常不是一見到這個題就能立刻理清思路。下面咱們用一個例子來講明，好比排列是(2,3,6,5,4,1)，求下一個排列的基本步驟是這樣：
1) 先從後往前找到第一個不是依次增加的數，記錄下位置p。好比例子中的3，對應的位置是1;
2) 接下來分兩種狀況：
    (1) 若是上面的數字都是依次增加的，那麼說明這是最後一個排列，下一個就是第一個，其實把全部數字反轉過來便可(好比(6,5,4,3,2,1)下一個是(1,2,3,4,5,6));
    (2) 不然，若是p存在，從p開始日後找，找找找，找到第一個比他bigger的數，而後兩個調換位置，好比例子中的4。調換位置後獲得(2,4,6,5,3,1)。最後把p以後的全部數字倒序，好比例子中獲得(2,4,1,3,5,6),  這個便是要求的下一個排列。

以上方法中，最壞狀況須要掃描數組三次，因此時間複雜度是O(3*n)=O(n)，空間複雜度是O(1)。代碼以下：」

 

 1 public class Solution {
 2     //http://blog.csdn.net/linhuanmars/article/details/20434115
 3     /*
 4     假設數組大小爲 n
 5         1.從後往前，找到第一個 A[i-1] < A[i]的。也就是第一個排列中的  6那個位置，能夠看到A[i]到A[n-1]這些都是單調遞減序列。
 6         2.從 A[n-1]到A[i]中找到一個比A[i-1]大的值（也就是說在A[n-1]到A[i]的值中找到比A[i-1]大的集合中的最小的一個值）
 7         3.交換 這兩個值，而且把A[n-1]到A[i+1]排序，從小到大。
 8     */
 9     public void nextPermutation(int[] num) {  
10         if(num==null || num.length==0)  
11             return;  
12         int i = num.length-2;  
13         while(i>=0 && num[i]>=num[i+1])  
14             i--;
15         
16         if(i>=0){  
17             int j=i+1;  
18             while(j<num.length && num[j]>num[i])
19                 j++;
20             j--;  
21             swap(num,i,j);  
22         }  
23         reverse(num, i+1,num.length-1);  
24     }    
25     private void swap(int[] num, int i, int j){  
26         int tmp = num[i];  
27         num[i] = num[j];  
28         num[j] = tmp;  
29     }  
30     private void reverse(int[] num, int i, int j){  
31         while(i < j)  
32             swap(num, i++, j--);  
33     }

 

 

 

Reference:

http://www.cnblogs.com/springfor/p/3896245.html

http://fisherlei.blogspot.com/2012/12/leetcode-next-permutation.html

http://blog.csdn.net/m6830098/article/details/17291259