[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

https://oj.leetcode.com/problems/next-permutation/

思路：以下圖。

該算法理解：

步驟1從右向左遍歷，若是一直是遞增序列，則已是當前子串的最後一個排列（極限狀況所有遞增，則表明是全串的最後一個排列），因此1步驟中須要尋找第一個遞減元素，即partitionNumber。此時的排列是以partitionNumber開頭的最大的排列（由於後面都遞減）。

步驟2中從右向左找第一個比partitionNumber大的元素，做爲新的稍微大一點的排列的頭，因此二者交換位置，而且後面的元素要reverse變成以新partitionNumber爲頭的最小排列。

 

第二遍記錄：
嚴格按照算法來便可。
　　注意比較的時候是否有等號
　　注意最後一個排列的特殊狀況，partitionIdx==-1。

 

import java.util.Arrays;

public class Solution {
    public void nextPermutation(int[] num) {
        if (num == null || num.length <= 1)
            return;
        int partitionIdx = -1;
        for (int i = num.length - 2; i >= 0; i--) {

            if (num[i] < num[i + 1]) {
                partitionIdx = i;
                break;
            }
        }
        if (partitionIdx == -1) {
            reverse(num, 0, num.length - 1);
            return;
        }

        int changeNumIdx = -1;
        for (int i = num.length - 1; i >= 0; i--) {

            if (num[i] > num[partitionIdx]) {
                changeNumIdx = i;
                break;
            }
        }
        int tmp = num[partitionIdx];
        num[partitionIdx] = num[changeNumIdx];
        num[changeNumIdx] = tmp;

        reverse(num, partitionIdx + 1, num.length - 1);

    }

    private void reverse(int[] a, int from, int to) {
        int i = from;
        int j = to;
        while (i < j) {
            int tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
            i++;
            j--;
        }
    }

    public static void main(String[] args) {
        int[] num;
        num = new int[] { 1, 2, 3, 5, 4, 4, 1 };
        new Solution().nextPermutation(num);
        System.out.println(Arrays.toString(num));

        num = new int[] { 1, 1, 5 };
        new Solution().nextPermutation(num);
        System.out.println(Arrays.toString(num));

        num = new int[] { 3, 2, 1 };
        new Solution().nextPermutation(num);
        System.out.println(Arrays.toString(num));

        num = new int[] { 1, 2, 3 };
        new Solution().nextPermutation(num);
        System.out.println(Arrays.toString(num));

        num = new int[] { 1, 1 };
        new Solution().nextPermutation(num);
        System.out.println(Arrays.toString(num));

    }
}

 

 

參考：

http://fisherlei.blogspot.com/2012/12/leetcode-next-permutation.html

擴展：

http://blog.csdn.net/m6830098/article/details/17291259