[LeetCode]Next Permutation下一个排列问题

当初把自己的代码贴在了discuss上，最近有人关于代码部分问了一些问题，现在总结一下这个题目吧。

一、问题描述

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

给定一个排列，求出它的下一个排列。

二、代码：先贴下代码吧，根据代码讲解一下我的思路

O(n)：

    int befoPos = -1, afterPos = -1;
    for (int i = nums.size()-2; i >= 0; --i) {
        if (nums[i] < nums[i+1]) {
            befoPos = i;
            break;
        }
    }
    if (befoPos == -1) {
        reverse(nums.begin(), nums.end());
        return;
    }
    for (int i = nums.size()-1; i >= 0; --i) {
        if (nums[befoPos] < nums[i]) {
            afterPos = i;
            break;
        }
    }
    swap(nums[befoPos], nums[afterPos]);
    reverse(nums.begin()+befoPos+1, nums.end());

Q: Hi,I have tried almost the same solution as yours. The only difference is that I used sort(nums.begin()+befoPos+1, nums.end()); instead of reverse(). But both are right, I don't know why this happens, do you know why?

A: For example, the given permutation is 3,4,1,6,5,2, and you got 1 at befoPos which is the first element from end that satisfies descending order with its after element. All the elements after befoPos is descending(including equals) so they are all larger than nums[befoPos]. 

    Then you want to deal the elements from 6 to 2. In the second loop, you need find the first element larger than nums[befoPos] from end and swap it with nums[befoPos]. As I explain above, it is the last element of nums and also the smallest element between befoPos+1 to end. 

    Now, its clear that the elements from befoPos+1 are descending. The only thing you need to do is reverse them. No matter you use reverse or sort, the aim is to generate a ascending order from befoPos+1 to end. Of course I think reverse is faster. ^_^