[Leetcode] 31. Next Permutation

Problem:

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

Idea:

1. Reverse find first number which breaks descending order.
2. Exchange this number with the least number that’s greater than this number.
3. Reverse sort the numbers after the exchanged number.

In detail,
1. Reversely from the last item, to find the target position i-1 that fulfills num[i-1] < num[i]. If cannot find the target position, which means the list strictly follows descending order, then swap items to make them into ascending order.
2. To find next permutation, we need to swap the number in target position i-1 with the smallest number between num[i,n-1] that is larger than num[i-1]
3. The last step, reversely sort the num[i,n-1] in ascending order.

Solution:
1. My Solution

class Solution(object):
    def nextPermutation(self, nums):
        """
        :type nums: List[int]
        :rtype: void Do not return anything, modify nums in-place instead.
        """
        if len(nums)<2:
            return
        if nums[-1]>nums[-2]:
            tmp=nums[-1]
            nums[-1]=nums[-2]
            nums[-2]=tmp
        else:
            for i in xrange(2,len(nums)+1):
                if nums[-i]==min(nums[-i:]) and nums[-i]!=min(nums[-i+1:]):
                    tmp=nums[-i]
                    nums[-i]=min(nums[-i+1:])
                    index = nums[-i+1:].index(nums[-i])
                    nums[-i+1+index]=tmp
                    tmpnums=nums[-i+1:]
                    tmpnums.sort()
                    nums[-i+1:]=tmpnums
                    return
                elif nums[-i]==max(nums[-i:]):
                    continue
                else:
                    tmp=nums[-i]
                    tmpnums=nums[-i:]
                    tmpnums.sort()
                    index = tmpnums.index(nums[-i])
                    while index+1 <= len(tmpnums) and tmpnums[index+1] == tmp:
                        index+=1
                    if index+1 >= len(tmpnums) :
                        continue
                    tar=tmpnums[index+1]
                    del tmpnums[index+1]
                    nums[-i]=tar
                    nums[-i+1:]=tmpnums
                    return
            nums.sort()

1. Better Solution
   
   1. Use swap() rather than deleting and inserting items in list.
   2. Don’t use sort() . Can refer the following function:

public void swap(int[] num, int i, int j){
    int temp=0;
    temp=num[i];
    num[i]=num[j];
    num[j]=temp;
}

public void reverseSort(int[] num, int start, int end){   
    if(start>end)
        return;
    for(int i=start;i<=(end+start)/2;i++)
        swap(num,i,start+end-i);
}