leetcode: Next Permutation

http://oj.leetcode.com/problems/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. 从前往后遍历，找到最后出现的那个满足A[i] < A[i + 1]的数，如果没有，说明数列已经是倒序的，比如[4, 3, 2, 1]，那么他的下一个排列很显然，倒序一把就是[1, 2, 3, 4]。
2. 找到一个位置index_1满足A[index_1] > A[index_1 + 1]后，从index_1位置开始，找到最小的比A[index_1]大的那个数，其位置为index_2，交换A[index_1]和A[index_2]，然后对区间index + 1到尾部进行排序。比如当前排列为[1, 2, 7, 4, 3, 6, 5]，找到index_1 = 4 (A[2] = 3)，找到index_2 = 6 (A[6] = 5)，交换后数组为[1, 2, 7, 4, 5, 6, 3]，对区间[5, 6]进行排序，得到下一个排列为[1, 2, 7, 4, 5, 3, 6]。 

class Solution {
public:
    void nextPermutation(vector<int> &num) {
        int size = num.size();
        
        if (size <= 1) {
            return;
        }
        
        int index_1 = -1;
        
        for (int i = 0; i < (size - 1); ++i) {
            if (num[i] < num[i + 1]) {
                index_1 = i;
            }
        }
        
        if (-1 == index_1) {
            reverse(num.begin(), num.end());
        }
        else {
            int min = INT_MAX, index_2;
            
            for (int i = index_1 + 1; i < size; ++i) {
                if (num[i] > num[index_1]) {
                    if (num[i] < min) {
                        min = num[i];
                        index_2 = i;
                    }
                }
            }
            
            swap(num[index_1], num[index_2]);
            sort(num.begin() + index_1 + 1, num.end());
        }
    }
};