[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