LeetCode-31-下一个排列

题目

来源：LeetCode.

整数数组的一个 排列  就是将其所有成员以序列或线性顺序排列。
例如，arr = [1,2,3] ，以下这些都可以视作 arr 的排列：[1,2,3]、[1,3,2]、[3,1,2]、[2,3,1] 。
整数数组的 下一个排列 是指其整数的下一个字典序更大的排列。
更正式地，如果数组的所有排列根据其字典顺序从小到大排列在一个容器中，
那么数组的 下一个   排列 就是在这个有序容器中排在它后面的那个排列。
如果不存在下一个更大的排列，那么这个数组必须重排为字典序最小的排列（即，其元素按升序排列）。

例如，arr = [1,2,3] 的下一个排列是 [1,3,2] 。
类似地，arr = [2,3,1] 的下一个排列是 [3,1,2] 。
而 arr = [3,2,1] 的下一个排列是 [1,2,3] ，因为 [3,2,1] 不存在一个字典序更大的排列。
给你一个整数数组 nums ，找出 nums 的下一个排列。
必须 原地 修改，只允许使用额外常数空间。

示例 1：

输入：nums = [1,2,3]
输出：[1,3,2]

示例 2：

输入：nums = [3,2,1]
输出：[1,2,3]

示例 3：

输入：nums = [1,1,5]
输出：[1,5,1]

提示：

• $1<=nums.length<=100$
• $0<=nums[i]<=100$

接下来看一下解题思路：

思路：两遍扫描：

    将给定数字序列重新排列成字典序中下一个更大的排列。

    以数字序列 $[1,2,3]$ 为例，其排列按照字典序依次为：

$$\begin{gathered} [1,2,3] \\ [1,3,2] \\ [2,1,3] \\ [2,3,1] \\ [3,1,2] \\ [3,2,1] \end{gathered}$$

这样，排列 $[2,3,1]$ 的下一个排列即为 $[3,1,2]$。特别的，最大的排列 $[3,2,1]$ 的下一个排列为最小的排列 $[1,2,3]$。

    希望找到一种方法，能够找到一个大于当前序列的新序列，且变大的幅度尽可能小。具体地：
    需要将一个左边的「较小数」与一个右边的「较大数」交换，以能够让当前排列变大，从而得到下一个排列。
    同时我们要让这个「较小数」尽量靠右，而「较大数」尽可能小。当交换完成后，「较大数」右边的数需要按照升序重新排列。这样可以在保证新排列大于原来排列的情况下，使变大的幅度尽可能小。

以排列 $[4,5,2,6,3,1]$ 为例：
    能找到的符合条件的一对「较小数」与「较大数」的组合为 $2$ 与 $3$，满足「较小数」尽量靠右，而「较大数」尽可能小。
    当完成交换后排列变为 $[4,5,3,6,2,1]$，此时可以重排「较小数」右边的序列，序列变为 $[4,5,3,1,2,6]$。

具体地，这样描述该算法，对于长度为 $n$ 的排列 $a$：

1. 从后向前查找第一个顺序对 $(i，i+1)$, 满足 $a[i]<a[i+1]$，
   （如果不存在，说明当前序列已经是降序序列，即最大序列，直接用步骤 $3$，得到最小的升序序列），
   这样较小数即为 $a[i]$，此时 $[i+1,n)$ 必然是下降序列；
2. 如果找到了顺序对，那么在区间 $[i+1,n)$ 中从后向前找到第一个元素 $j$, 满足 $a[i]<a[j]$。这样较大数即为 $a[j]$
3. 交换 $a[i]$ 与 $a[j]$,此时区间 $[i+1,n)$ 必为降序，可以使用双指针反转区间，使其变为升序；

public static void nextPermutation(int[] nums) {
    if (nums == null || nums.length <= 0) {
        return;
    }

    int i = nums.length - 2;

    // 从后往前寻找第一个满足 a[i] < a[i + 1] 的顺序对
    while (i >= 0 && nums[i] >= nums[i + 1]) {
        --i;
    }

    if (i >= 0) {
        int j = nums.length - 1;
        // 在 [i + 1, n) 区间，从后往前找第一个元素 j, 满足 a[i] < a[j]
        // 能走到这，说明一定存在一个满足条件的 j,所以不用担心 j 下标越界
        while (nums[i] >= nums[j]) {
            --j;
        }
        // 交换 i 和 j
        swap(nums, i, j);
    }
    // 反转 [i + 1, n) 区间的序列
    reverse(i + 1, nums);
}

private static void swap(int[] nums, int i, int j) {
    int tmp = nums[i];
    nums[i] = nums[j];
    nums[j] = tmp;
}

private static void reverse(int left, int[] nums) {
    int right = nums.length - 1;
    while (left < right) {
        swap(nums, left, right);
        ++left;
        --right;
    }
}

复杂度分析

时间复杂度：$O(N)$，其中 $N$ 为给定序列的长度。我们至多只需要扫描两次序列，以及进行一次反转操作。

空间复杂度：$O(1)$，只需要常数的空间存放若干变量。