挑战30天每天一道leetcode题：Day3 下一个排列

题目：31.下一个排列

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

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

链接：. - 力扣（LeetCode）

参考答案：

方法：一遍扫描

思路：

先从右往左找第一个顶点，这个顶点的左边一个数就是k点（关键点），找出k点后面所有数中比k大一点点的值，  最后将所有k值右边剩余的元素进行升序排列。

代码：

package com.atguigu.algorithm.arrays;

import java.util.Arrays;

public class NextPermutation {
    //思路：从后向前找到升序的序列，然后确定调整后的子序列的最高位，剩余部分升序排列.[1,3,8,7,6,2]
    public void newPermutation(int[] nums) {
        int n = nums.length;

        // 1.从后往前找到升序的子序列，找到第一次下降的数，位置记为k。即升序最低点
        int k = n - 2;
        while (k >= 0 && nums[k] >= nums[k + 1]) {
            k--;
        }

        //  找到k，就是需要调整部分的最高位
        // 2.如果k=-1,说明所有数降序排列，改成升序排列。反转
        if (k == -1) {
            //            Arrays.sort(nums);
            reverse(nums, 0, n - 1);
            return;
        }

        // 3. 一般情况下，k>=0
        // 3.1  依次遍历升序降序排列的部分，找到要替换最高位的那个数。i为比k大一点，可以替换k的数，从k+2开始找
        int i = k + 2;
        while (i < n && nums[i] > nums[k]) {
            i++;
        }

        //当前的i,就是后面部分第一个比nums[k]小的数，i-1就是要替换的那个数
        // 3.2 交换i-1和k位置上的数
        //        int temp = nums[k];
        //        nums[k] = nums[i - 1];
        //        nums[i - 1] = temp;
        swap(nums, k, i - 1);

        // 3.3 k之后的剩余部分变成升序排列，知道前后调换。用双指针法
        //        int start = k + 1;
        //        int end = n - 1;
        //        while (start < end) {
        //            int tmp = nums[start];
        //            nums[start] = nums[end];
        //            nums[end] = tmp;
        //            start++;
        //            end--;
        //        }
        reverse(nums, k + 1, n - 1);
    }

    //  定义一个方法，交换数组中两个元素
    private void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }

    //  定义一个翻转数组的方法
    private void reverse(int[] nums, int start, int end) {
        while (start < end) {
            swap(nums, start, end);
            start++;
            end--;
        }
    }




    public static void main(String[] args) {
        int[] nums = {1,3,8,7,6,2};
        NextPermutation permutation = new NextPermutation();
        permutation.newPermutation(nums);
        for (int num : nums) {
            System.out.print(num + "\t");
        }
    }

}

排序后的结果是

复杂度分析

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

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

说明

注释的代码是初始的，后面优化提出来重复的代码就优化了