LeetCode hot100 31. 下一个排列

原创已于 2023-03-20 12:33:12 修改 · 177 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #算法 #数据结构

于 2023-03-20 12:30:26 首次发布

算法刷题笔记专栏收录该内容

2 篇文章

订阅专栏

给定一个整数数组nums，找出它的下一个排列，要求原地修改且只允许使用额外常数空间。算法通过从后向前遍历找到升序子序列，然后交换合适的元素以形成下一个字典序更大的排列。若找不到升序子序列，则说明数组已是最大排列，需转为最小排列。

LeetCode hot100 31. 下一个排列

题目描述

题目难度

middle

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

例如，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 的下一个排列。

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

题目理解

求当前排列的下一个排列，可以将当前排列抽象为一个int数，即求比当前数大的最小的那个数，比如12345，他的下一个排列就是12354，而如果当前数是最大的，比如54321，那么他的下一个排列就是最小的那个数，即12345。

思路

1.从后往前遍历，找到一个升序的 [i, j] , 如123465，记录此时i位置和j位置，在j之后找到一个比 nums[i] 大的最小的数5，即123465，交换这两个数 --> 123564；（把 i 位置记录为left，找到的最小大数“5”的位置记录为right，后序是交换这两个指针的位置，双指针应用体现于此）
2.此时发现 [j , len-1] 这段是“64”是升序，这显然不符合“找到最小的下一个大数”的定义，因此转换它为降序
123564 --> 123546；

Java实现

class Solution {
    public void nextPermutation(int[] nums) {
        int len = nums.length;
        int left = 0;
        int right = 0;
        int temp = 0;
        int flag = 0;

        for(int i=len-2; i>=0; i--){
            if(nums[i] < nums[i+1]){
                left = i;
                temp = i+1;
                flag = 1;
                break;
            }
        }

        if(flag == 0){
            int start = 0;
            int end = len-1;
            while(start<end){
                int r = nums[start];
                nums[start] = nums[end];
                nums[end] = r;
                start++;
                end--;
            }
            return ;
        }


        int min = Integer.MAX_VALUE;
        for(int i=temp; i<len; i++){
            if(nums[i]>nums[left] && nums[i]-nums[left]<min){
                min = nums[i]-nums[left];
                right = i;
            }    
        }

        if(min == Integer.MAX_VALUE){
            right = temp;
        }

        //swap
        int tmp = nums[left];
        nums[left] = nums[right];
        nums[right] = tmp;

        //判断后段 是否是降序
        int goLow = 0;
        for(int m = temp; m<len-1; m++){
            //有降序
            if(nums[m] > nums[m+1]){
                goLow = 1;
                break;
            }
        }

        if(goLow == 0)
            return ;
        
        Arrays.sort(nums, temp, len);

        return ;
    }
}