LeetCode 31. 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  2  3  5  9        1  2  3  9  5
1  2  9  5  3        1  3  2  5  9
1  3  2  9  5        1  3  5  2  9

从序列末尾往前看，找到第一个序列下降的地方，比如1 2 9 5 3，从后往前第一个下降的是2。然后从2往后，找第一个比2大的数字，得到3，交换2和3得到序列1 3 9 5 2。再把此时3后面的所有数字倒置一下即可。

规律是找到了，但是一开始代码写得很啰嗦：

void nextPermutation(vector<int>& nums) {
        int size = nums.size();
        int tempMax = nums[size - 1], tempIndex;
        //寻找局部极大值的位置
        for (int i = 1; i <= size; i++)
        {
            if (nums[size - i] >= tempMax) {
                tempMax = nums[size - i];
                tempIndex = i;
            }
            else {
                break;
            }
        }
        //数组值完全下降
        if (tempIndex == size) {
            reverse(nums, 0, size - 1);
        }
        //尾上升
        else if (tempIndex == 1) {
            reverse(nums, size - 2, size - 1);
        }
        else {
            //寻找
            int head = size - tempIndex - 1;
            int low = size - tempIndex, high = size - 1, mid;
            while (low < high)
            {
                if (low + 1 == high)
                {
                    if (nums[head] >= nums[high]) mid = low;
                    else mid = high;
                    break;
                }
                mid = (low + high) / 2;
                if (nums[head] >= nums[mid]) high = mid;
                else low = mid;

            }
            //交换
            int temp = nums[head];
            nums[head] = nums[mid];
            nums[mid] = temp;

            reverse(nums, size - tempIndex, size - 1);
        }
    }

void reverse(vector<int>& nums, int beg, int end) {
        while (beg < end)
        {
            int temp = nums[beg];
            nums[beg] = nums[end];
            nums[end] = temp;
            ++beg;
            --end;
        }
    }

重新思考了一下后修改了代码：

void nextPermutation(vector<int>& nums) {
        int size = nums.size();
        for (int i = size - 1; i >= 1; i--) {
            if (nums[i] > nums[i - 1])
            {
                int j;
                for (j = size - 1; j >= i; j--) {
                    if (nums[j] > nums[i - 1]) break;
                }
                swap(nums[j], nums[i - 1]);
                reverse(nums.begin() + i, nums.end());
                return;
            }
        }
        //是全递减序列
        reverse(nums.begin(), nums.end());
    }