LeetCode刷题之【下一个排列】

最新推荐文章于 2022-01-24 17:33:34 发布

麦田里的守望者_zhg

最新推荐文章于 2022-01-24 17:33:34 发布

阅读量210

点赞数

CC 4.0 BY-SA版权

分类专栏：面试刷题 java 算法文章标签：算法 leetcode 数据结构动态规划 java

本文链接：https://blog.youkuaiyun.com/qq_33521184/article/details/109607713

java 同时被 3 个专栏收录

86 篇文章

订阅专栏

算法

62 篇文章

订阅专栏

面试刷题

57 篇文章

订阅专栏

本文介绍了一个算法问题——下一个排列的解决方案。该问题要求实现一个函数，能够将给定的数字序列重新排列为字典序中下一个更大的排列。若不存在更大排列，则重新排列为最小的排列（即升序排列）。文章详细解释了算法思路，并提供了Java代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1 题目

实现获取下一个排列的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。

如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。

必须原地修改，只允许使用额外常数空间。

以下是一些例子，输入位于左侧列，其相应输出位于右侧列。
1,2,3 → 1,3,2
3,2,1 → 1,2,3
1,1,5 → 1,5,1

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/next-permutation
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2 解释思路

从后往前遍历数组，找到第一个小于当前索引位置的数，假设当前索引是 $i$ ，则找到 $i - 1$ ，有以下三种情况：

1. $i = = n u m s . l e n g t h$ ，说明数组是一个升序数组，直接交换 $n u m s [i]$ 和 $n u m s [i - 1]$ 的位置即可，如 $123$ -> $132$

2. $0 < i < n u m s . l e n g t h$ ，说明这样的数在数组中间，直接从第 $[i . . . n u m s . l e n g t h]$ 的数中找到一个大于且仅大于 $n u m s [i - 1]$ 的数，即这个数是 $[i . . . n u m s . l e n g t h]$ 中大于 $n u m s [i - 1]$ 中最小的，假设该索引是 $m i n$ ，然后交换 $n u m s [i - 1]$ 和 $n u m s [m i n]$ 的值，并将 $[i . . . n u m s . l e n g t h]$ 中的所有数进行升序排序，便是最终答案

3. $i = = 0$ ，说明数组是一个倒序的数组，直接将数组 $r e v e r s e$ 即可。

class Solution {
    public void nextPermutation(int[] nums) {
        if (nums.length == 1)
            return;
        int i = nums.length - 1;
        for (; i > 0; i--) {
            if (nums[i] <= nums[i - 1]) continue;
            //12345 -> 12354
            if (i == nums.length - 1) {
                nums[i] = nums[i - 1] ^ nums[i];
                nums[i - 1] = nums[i - 1] ^ nums[i];
                nums[i] = nums[i - 1] ^ nums[i];
                return;
            }
            int min = i; //从[i,nums.length-1]的闭区间中找到一个大于nums[i - 1]的最小的值，并与nums[i - 1]交换
            for (int j = nums.length - 1; j >= i; j--) {
                if (nums[j] > nums[i - 1] && nums[j] < nums[min])
                    min = j;
            }

            nums[i- 1] = nums[i - 1] ^ nums[min];
            nums[min] = nums[i - 1] ^ nums[min];
            nums[i- 1] = nums[i - 1] ^ nums[min];

            //将第i个位置以后的数字进行升序排序
            for (int j = i; j < nums.length - 1; j++) {
                for (int k = i; k < nums.length - 1; k++) {
                    if (nums[k] > nums[k + 1]) {
                        nums[k] = nums[k] ^ nums[k + 1];
                        nums[k + 1] = nums[k] ^ nums[k + 1];
                        nums[k] = nums[k] ^ nums[k + 1];
                    }
                }
            }

            return;
        }
        //倒序数组
        int l = 0, r = nums.length - 1;
        while (l < r) {
            nums[l] = nums[l] ^ nums[r];
            nums[r] = nums[l] ^ nums[r];
            nums[l] = nums[l] ^ nums[r];
            l ++;
            r --;
        }
    }
}