题目
来源: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 < = n u m s . l e n g t h < = 100 1 <= nums.length <= 100 1<=nums.length<=100
- 0 < = n u m s [ i ] < = 100 0 <= nums[i] <= 100 0<=nums[i]<=100
接下来看一下解题思路:
思路:两遍扫描:
将给定数字序列重新排列成字典序中下一个更大的排列。
以数字序列 [ 1 , 2 , 3 ] [1,2,3] [1,2,3] 为例,其排列按照字典序依次为:
[ 1 , 2 , 3 ] [ 1 , 3 , 2 ] [ 2 , 1 , 3 ] [ 2 , 3 , 1 ] [ 3 , 1 , 2 ] [ 3 , 2 , 1 ] [1,2,3]\\ [1,3,2]\\ [2,1,3]\\ [2,3,1]\\ [3,1,2]\\ [3,2,1] [1,2,3][1,3,2][2,1,3][2,3,1][3,1,2][3,2,1]
这样,排列 [ 2 , 3 , 1 ] [2,3,1] [2,3,1] 的下一个排列即为 [ 3 , 1 , 2 ] [3,1,2] [3,1,2]。特别的,最大的排列 [ 3 , 2 , 1 ] [3,2,1] [3,2,1] 的下一个排列为最小的排列 [ 1 , 2 , 3 ] [1,2,3] [1,2,3]。
希望找到一种方法,能够找到一个大于当前序列的新序列,且变大的幅度尽可能小。具体地:
需要将一个左边的「较小数」与一个右边的「较大数」交换,以能够让当前排列变大,从而得到下一个排列。
同时我们要让这个「较小数」尽量靠右,而「较大数」尽可能小。当交换完成后,「较大数」右边的数需要按照升序重新排列。这样可以在保证新排列大于原来排列的情况下,使变大的幅度尽可能小。
以排列
[
4
,
5
,
2
,
6
,
3
,
1
]
[4,5,2,6,3,1]
[4,5,2,6,3,1] 为例:
能找到的符合条件的一对「较小数」与「较大数」的组合为
2
2
2 与
3
3
3,满足「较小数」尽量靠右,而「较大数」尽可能小。
当完成交换后排列变为
[
4
,
5
,
3
,
6
,
2
,
1
]
[4,5,3,6,2,1]
[4,5,3,6,2,1],此时可以重排「较小数」右边的序列,序列变为
[
4
,
5
,
3
,
1
,
2
,
6
]
[4,5,3,1,2,6]
[4,5,3,1,2,6]。
具体地,这样描述该算法,对于长度为 n n n 的排列 a a a:
- 从后向前查找第一个顺序对
(
i
,
i
+
1
)
(i, i + 1)
(i,i+1), 满足
a
[
i
]
<
a
[
i
+
1
]
a[i] < a[i + 1]
a[i]<a[i+1],
(如果不存在,说明当前序列已经是降序序列,即最大序列,直接用步骤 3 3 3,得到最小的升序序列),
这样较小数即为 a [ i ] a[i] a[i],此时 [ i + 1 , n ) [i + 1, n) [i+1,n) 必然是下降序列; - 如果找到了顺序对,那么在区间 [ i + 1 , n ) [i + 1, n) [i+1,n) 中从后向前找到第一个元素 j j j, 满足 a [ i ] < a [ j ] a[i] < a[j] a[i]<a[j]。这样较大数即为 a [ j ] a[j] a[j]
- 交换 a [ i ] a[i] a[i] 与 a [ j ] a[j] a[j],此时区间 [ i + 1 , n ) [i + 1, n) [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 ) O(N) O(N),其中 N N N 为给定序列的长度。我们至多只需要扫描两次序列,以及进行一次反转操作。
空间复杂度: O ( 1 ) O(1) O(1),只需要常数的空间存放若干变量。