31. 下一个排列

鲁迅说过，这是 2 月的最后一天了，3 月将迎来社招的高峰期，以及春招的高峰

期，希望大家都能坚持住，别掉队。二哥的 LeetCode 刷题会继续陪伴大家，希

望能给大家带去更多解题的思路，以及学习 Java 的乐趣。

题意

整数数组的一个 排列 就是将其所有成员以序列或线性顺序排列。

例如，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]

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

输出：[1,2,3]

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

输出：[1,5,1]

分析 1

这道题看起来很唬人，比如题目描述中提到的“字典序”，很多球友第一眼看到这个名词的

时候会有点懵，这里简单解释一下。

字典序（dictionary order），又称 字母序（alphabetical order），原意是表示英文单词

在字典中的先后顺序，在计算机领域中扩展成两个任意字符串的大小关系。

在这道题目中，字典序其实是指☞ 数字大小的先后顺序。

理解了“字典序”，就能很快理解这道题的题意了：要我们求出比这个数更大的一个排列，

比 如 123，比它大的是 132，对吧？只需要改变 23 的位置就可以了。312 也比 123 大，

?

只不过它是比 132 更大的一个，不是比 123 更

压（ ）。

大

的一

个，

官

大一

级压

死

人，

一级

一

级来

就好像我们在打扑克牌，我出了一个对 10，

那

你出

对11 就压住我了，没必要把手里的对 12 先出

来

，

对吧

？

再比如 321 已经是「1、2、3」 这三个数字组合中最大的那个了，那就等于说没有更大的

了 ， 所 以 返 回 123 这个最小的。

明白了吧？

? 题 理

意 ， 所 以 文

要想解 ，首先得明白意，所以

。

）

（

次

其

，

的

要

重

常

非

是

解 语 文 理 解 是 非 常 重 要 的 ， 其 次 是 经 验 （ ? ） 。

那凭借我们以往的经验，可能一下子会想到全排列。就拿 1、2、3、4 来举

例吧，全排列如

下

：

nums = [1,2,3,4]

nums = [1,2,4,3]

nums = [1,3,2,4]

nums = [1,3,4,2]

nums = [1,4,2,3]

nums = [1,4,3,2]

nums = [2,1,3,4]

nums = [2,1,4,3]

nums = [2,3,1,4]

nums = [2,3,4,1]

nums = [2,4,1,3]

nums = [2,4,3,1]

nums = [3,1,2,4]

nums = [3,1,4,2]

nums = [3,2,1,4]

nums = [3,2,4,1]

nums = [3,4,1,2]

nums = [3,4,2,1]

nums = [4,1,2,3]

nums = [4,1,3,2]

nums = [4,2,1,3]

nums = [4,2,3,1]

nums = [4,3,1,2]

nums = [4,3,2,1]

观察 nums = [1,3,4,2] -> nums = [1,4,2,3]这一步，因为 4 比 3 大

，

且4 的位置在 3 之后，所

以将 4 与 3 交换，必然能够使得 nums 大，交了之后，成了 nums = [1,4,3,2]。

但显然这不是最小的比 nums = [1,3,4,2]大的一个排列，我要把 3 和 2 的位置再翻转一

下，才能得到 nums = [1,4,2,3]这个 恰好 比 nums = [1,3,4,2]大一点的排列。

那到底该怎么去找到这个 恰好 比 nums 大 一 点 的 排 列 呢 ？

第一步，我们可以从右向左查找第一个升序的相邻数字对 (i, i+1)，满足 nums[i] <

nums[i+1]。

这意味着从 i+1 到末尾的数字都是降序的。如果找不到这样的 i（即整个数是降序

的），这说明当前排列已经是最大的排列，我们只需将其翻转为最小排列即可。

031.%E4%B8%8B%E4%B8%80%E4%B8%AA%E6%8E%92%E5%88%97-

20240229152950.png

这一步完成之后，并不能保证我们得到的排列就是 恰好 比 nums 大一点的排列。

第二步，我们还要对 nums[i+1] 到 nums[nums.length - 1]这个区间进行翻转，使得它

变成升序排列，这样才能得到 恰好 比 nums 大一点的排列。

比如上面提到的 [1,4,3,2]，i+1（ i=1）到末尾的部分是 32。这部分是降序的。为了得到

下一个排列，我们需要这部分变成升序。我们需要将这部分翻转，变成 23。

031.%E4%B8%8B%E4%B8%80%E4%B8%AA%E6%8E%92%E5%88%97-

20240229153646.png

所以到这里，这道题目就迎刃而解了。具体代码实现：

class Solution {

public void nextPermutation(int[] nums) {

// 步骤 1：从右向左查找第一个升序的相邻数字对(i, i+1)，满足 nums[i] <

nums[i+1]。

int i = nums.length - 2;

while (i >= 0 && nums[i] >= nums[i + 1]) {

i--;

}

if (i >= 0) {

// 步骤 2：在 nums[i+1:]中从右向左找到第一个大于 nums[i]的数字 nums[j]。

int j = nums.length - 1;

while (j >= 0 && nums[i] >= nums[j]) {

j--;

}

// 步骤 3：交换 nums[i]和 nums[j]。

swap(nums, i, j);

}

// 步骤 4：将 nums[i+1:]翻转，使其变为升序。

reverse(nums, i + 1);

}

// 用于交换数组中两个元素的位置

private void swap(int[] nums, int i, int j) {

int temp = nums[i];

nums[i] = nums[j];

 nums[j] = temp;

}

// 用于将数组的一部分翻转，即将 nums[start:]变为升序

private void reverse(int[] nums, int start) {

int end = nums.length - 1;

while (start < end) {

swap(nums, start, end);

start++;

end--;

}

}

}

为了更清晰地理解题解代码，我们将其拆分成几个关键部分，并逐一说明每部分的作用和

逻辑。

1.寻找升序对 (i, i+1)

int i = nums.length - 2;

while (i >= 0 && nums[i] >= nums[i + 1]) {

i--;

}

• 目的：从数组的右端开始向左扫描，寻找第一个升序的相邻数字对，即找到第一个

nums[i] < nums[i + 1]的位置。这个位置 i 是需要进行调整的起点，因为 nums[i]右

边的序列是降序的，没有更大的排列空间。

• 逻辑：使用一个 while 循环从右向左遍历数组，直到找到满足升序条件的 i。

2.在 nums[i+1:] 中找到第一个大于 nums[i] 的数字并交换

nums[i+1:] 是指从 i+1 到数末尾的部分。

if (i >= 0) {

int j = nums.length - 1;

while (j >= 0 && nums[i] >= nums[j]) {

j--;

}

swap(nums, i, j);

}

• 目的：如果找到了这样的 i，则在其右侧找到第一个大于 nums[i]的 数 字 nums[j]，然

后交换 nums[i]和 nums[j]。一步是了在当前排列的基上得到下一个稍大的数

字 。

• 逻辑：通过向左扫描数组的剩余部分来查找 j，一旦找到就行交。

3.翻转 nums[i+1:] 使其升序

reverse(nums, i + 1);

• 目的：交换 nums[i]和 nums[j]后，i 之后的序列仍然保持降序。为了获得下一个排

列

，

需要

将个

序

列翻

成升

序

，从 i+1 到数末尾就成了最小的排列，确保整个数是下一个更大的排列。

• 逻辑：从 i+1 开始到数组末尾，执行翻转操作，使其成为升序。

4.交换方法 swap

private void swap(int[] nums, int i, int j) {

int temp = nums[i];

nums[i] = nums[j];

nums[j] = temp;

}

交换数组中两个位置的元素。

5.翻转方法 reverse

private void reverse(int[] nums, int start) {

int end = nums.length - 1;

while (start < end) {

swap(nums, start, end);

start++;

end--;

}

}

将数组从指定位置 start 到数末尾的部分翻，使其成升序。

效率嘛，自然是快得飞起。

031.%E4%B8%8B%E4%B8%80%E4%B8%AA%E6%8E%92%E5%88%97-

20240229154806.png

分析 2

其实在 Java 中，Arrays.sort 方法可以来辅助完成排序/反转的工作。

比 如 说 [4,3,2,1]， 我 们直 接 对他 进行 sort 排

序

，就

会得

到[1,2,3,4]，

对

吧？

也就是说，如果不存在下一个更大的排列，那么，我们可以使用 sort 方法将这个数组重

排字典序最小的排列（即，其元素按升序排列）。

除此之外，在分析 1 中，我们需要对剩余的整数进行升序排列时，我们使用了一个

reverse 方法，其实我们可以直接使用 Arrays.sort(nums, i + 1, nums.length) 来完成翻转

的

工作

。

031.%E4%B8%8B%E4%B8%80%E4%B8%AA%E6%8E%92%E5%88%97-

20240229160705.png

所以，我可以将代改写：

class Solution {

public void nextPermutation(int[] nums) {

 boolean found = false;

for (int i = nums.length - 2; i >= 0; i--) {

if (nums[i] < nums[i + 1]) {

// 从右向左寻找第一个大于 nums[i]的数字

for (int j = nums.length - 1; j > i; j--) {

if (nums[j] > nums[i]) {

// 交换 nums[i]和 nums[j]

swap(nums, i, j);

// 将 i+1 到数组末尾的部分进行排序

Arrays.sort(nums, i + 1, nums.length);

found = true;

break;

}

}

if (found) break;

}

}

// 如果没有找到升序对，说明数组是降序的，直接排序得到最小排列

if (!found) {

Arrays.sort(nums);

}

}

// 交换数组中的两个元素

private void swap(int[] nums, int i, int j) {

int temp = nums[i];

nums[i] = nums[j];

nums[j] = temp;

}

}

实现步骤上其实差不多：

• 第一步，从右向左寻找第一个升序对 (i, i+1)，满足 nums[i] < nums[i+1]。

• 第二步，从右向左寻找第一个大于 nums[i] 的数字 nums[j]，并交换 nums[i] 和

nums[j]。

• 第三步，将 nums[i+1] 以后的元素进行排序。

因为排序的效率没有反转来得直接，所以效率下降了一些，但应该是更好理解了。

031.%E4%B8%8B%E4%B8%80%E4%B8%AA%E6%8E%92%E5%88%97-

20240229161736.png

总结

道目的点其在于字典序的理解，一旦理解之后，整个目的解法就不算是特

了。

涉及到的 Java 基础知识也不多：

• 数 组 的 遍 历

• Arrays 类

力扣链接：https://leetcode.cn/problems/next-permutation/