Leetcode-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

Have you met this question in a real interview?

 

Analysis:

Starting from the last position, the first time we find that num[i]>num[i-1], we stop. The position i is the position that will be increased. We need to find out the next large num in num[i+1...len-1] and change num[i] to that number. Suppose it is num[j], then num[i]=num[j]. For the rest part to the array, we arrange them in an increasing order of num[i]...num[len-1] except num[j].

 

Solution:

public class Solution {
    public void nextPermutation(int[] num) {
        int len = num.length;
        if (len==0 || len==1) return;
        
        List<Integer> list = new LinkedList<Integer>();
        int index = len-2;
        list.add(num[len-1]);
        while (index>=0 && num[index]>=num[index+1]){
            list.add(num[index]);
            index--;
        }
        if (index>=0){
            list.add(num[index]);
            int bar = num[index];
            Collections.sort(list);
            int index2 = 0;
            while (!(list.get(index2)==bar && list.get(index2+1)!=bar)) index2++;
            int newVal = list.get(index2+1);
            num[index] = newVal;
            list.remove(index2+1);
            for (int i=0;i<list.size();i++){
                index++;
                num[index]=list.get(i);
            }
        } else {
            Collections.sort(list);
            for (int i=0;i<list.size();i++)
                num[i]=list.get(i);
        }

        return;
        
    }
}

Solution 2:

The solution 1 is O(nlogn) complexity, because we sort the part num[i]...num[len-1]. However, we actually can observe that the part num[i+1]...num[len-1] is actually reversely ordered already. Therefore, all we need to do is find out num[j], and reverse the part num[i]...num[len-1]. The complexity is decreased to O(n).

public class Solution {
    public void nextPermutation(int[] num) {
        int len = num.length;
        if (len==0 || len==1) return;
        
        
        int index = len-2;        
        while (index>=0 && num[index]>=num[index+1]){
            index--;
        }
        if (index>=0){
            int bar = num[index];         
            int index2 = index+1;
            while (!(index2+1>=len || (num[index2]>bar && num[index2+1]<=bar))) index2++;
            num[index]=num[index2];
            num[index2] = bar;
            reverse(num,index+1,len-1);
        } else {
            reverse(num,0,len-1);
        }

        return;
    }

    public void reverse(int[] num,int start,int end){
        while (start<end){
            int temp = num[start];
            num[start] = num[end];
            num[end] = temp;
            start++;
            end--;
        }
    }
}