Leetcode | 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

分析了一下，得出有如下规律，accepted。大致思路和网上同样。红色部分是网上的解法。

1. 从右往左扫，找到第一个不符合num[i]>=num[i+1]的数；

2. 而后从[i+1...n-1]中找到比num[i]大的最小数num[j]；这里我直接找大于num[i]的最小值了；其实由于[i+1..n-1]是递减的，能够从右往左扫，找到第一个数就退出就好了。

3. 交换num[j]和num[i]；交换以后，仍然会保证[i+1...n-1]是递减的。

4. 对[i+1...n-1]进行排序；由于[i+1...n-1]是递减的，直接reverse就能够了，不须要排序。 

5. 若是找到的数i<0，也就是整个序列都是递减的，那么直接排序就行；一样能够用reverse。

 1 class Solution {
 2 public:
 3     void nextPermutation(vector<int> &num) {
 4         int i;
 5         for (i = num.size() - 2; i >= 0; --i) {
 6             if (num[i] >= num[i + 1]) continue;
 7             int minIndex = i + 1;
 8             for (int j = i + 1; j < num.size(); ++j) {
 9                 if (num[j] > num[i] && num[j] < num[minIndex]) minIndex = j;
10             }
11             swap(num[i], num[minIndex]);
12             sort(num.begin() + i + 1, num.end());
13             break;
14         }
15         if (i < 0) sort(num.begin(), num.end());
16     }
17 };

不过由于能够不用写reverse的代码，直接用sort看起来简洁得多。重构了一下代码就是：

 1 class Solution {
 2 public:
 3     void nextPermutation(vector<int> &num) {
 4         int i, j;
 5         for (i = num.size() - 2; i >= 0 && num[i] >= num[i + 1]; --i); 
 6         if (i >= 0) {
 7             for (j = num.size() - 1; j > i && num[j] <= num[i]; --j); 
 8             swap(num[i], num[j]);
 9         } 
10         sort(num.begin() + i + 1, num.end());
11     }
12 };