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

大意：找到某一个数字序列按照字典排序的下一个序列。直接修改原序列，不需要返回。

思路：关键是如何找到 下一个序列的方法。字典排序就是全排序 然后按大小递增的排序关系，所以下一个序列就是比当前序列大一点点的那个序列。
怎么通过交换元素使当前序列变大呢。还要是仅比当前序列大。
从序列末尾开始back 依次向前检索。到某一位置，遍历在该位置之后的元素，如果里面有元素大于当前位置的nums[back]。则交换之。
注意从后往前遍历，找到所有比当前序列大的序列集合中最小的那个。就是前面尽可能多的位数不动，从后往前调整的位数越后越好。
交换完了之后，从back位置往后再逆序 即可 。因为 后面的元素序列每一位的后面都没有比它自己大元素。所以递增排序 直接将后面元素序列逆序即可。

class Solution(object):
    def nextPermutation(self, nums):
        """
        :type nums: List[int]
        :rtype: void Do not return anything, modify nums in-place instead.
        """
        l=len(nums)
        if l>=2:
            end=l-1
            back=end-1
            start=0
            flag=False
            while(back>=0):
                start=end
                while(start>back):
                    if nums[back]<nums[start]:
                        tmp=nums[back]
                        nums[back]=nums[start]
                        nums[start]=tmp
                        flag=True
                        break
                    start=start-1
                if flag==True:break
                back=back-1
            front=back+1
            while(front<end):
                temp=nums[front]
                nums[front]=nums[end]
                nums[end]=temp
                front=front+1
                end=end-1

back：从后往前便利每一back位置
start：对应每一个 back位置从后往前数，找有没有大于该位置元素的数
front：交换完back后一个位置元素，逆序起点
end：逆序终点，序列末尾
flag：循环跳出控制标志

python 68ms AC。

c++:

class Solution {
public:
    void nextPermutation(vector<int> &num) {
        if (num.size() <= 1) return;

        int i = (int)num.size() - 1;
        while (i > 0 && num[i] <= num[i-1])
            --i;
        if (i == 0) {
            reverse(num.begin(), num.end());
            return;
        }

        --i;
        int j = (int)num.size() - 1;
        while (!(num[i] < num[j])) 
            --j;

        swap(num[i], num[j]);
        reverse(num.begin() + i + 1, num.end());
    }
};

摘抄《STL源码剖析》:
在当前序列中，从尾端往前寻找两个相邻元素，前一个记为*i，后一个记为*ii，并且满足*i < *ii。然后再从尾端寻找另一个元素*j，如果满足*i < *j，即将第i个元素与第j个元素对调，并将第ii个元素之后（包括ii）的所有元素颠倒排序，即求出下一个序列了。