算法-leetcode-数组问题-31. 下一个排列

https://leetcode-cn.com/problems/next-permutation/

下一个排列

• 如下图所示：
  

• 1, 从右往左，找到第一个下降的点p1,

• 2, 然后从p1右侧：从左往右，找到第一个等于或着小于p1的点p2。然后p2点往前推一个点：p3就是比p1次大的数字。

• 3, 把p1/p3进行交换后，然后把p1右侧的所有数字：逆序调整一下即可(从右往左看，是升序，我们逆序为降序即可)

代码解法1：内部使用双指针进行逆转

• 这里代码效率要高于解法1

package com.shangguigu.dachang.algrithm.A01_arrays;

import java.util.ArrayList;
import java.util.Arrays;

/**
 * @author : 不二
 * @date : 2021/12/21-下午2:47
 * @desc :
 *
 * 31. 下一个排列
 * 实现获取 下一个排列 的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列（即，组合出下一个更大的整数）。
 *
 * 如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。
 *
 * 必须 原地 修改，只允许使用额外常数空间。
 *
 *
 *
 * 示例 1：
 *
 * 输入：nums = [1,2,3]
 * 输出：[1,3,2]
 * 示例 2：
 *
 * 输入：nums = [3,2,1]
 * 输出：[1,2,3]
 * 示例 3：
 *
 * 输入：nums = [1,1,5]
 * 输出：[1,5,1]
 * 示例 4：
 *
 * 输入：nums = [1]
 * 输出：[1]
 *
 *
 * 提示：
 *
 * 1 <= nums.length <= 100
 * 0 <= nums[i] <= 100
 *
 **/
public class A17_nextPermutation {

    public static void main(String[] args) {
        int[] nums = {1, 2, 3};
        nextPermutation(nums);
        for (int i = 0; i < nums.length; i++) {
            System.out.println("结果是：" + nums[i]);
        }

    }

    public static void nextPermutation(int[] nums) {
        // 从后往前， 找到第一个降低的数字， 然后把该数字：与后面比该数次大的数字交换，最后把该数字后面的所有数字从小到大排列
        // 如果从后往前找不到降低的数字，说明是一直升高的。那么这个数字就是不存在下一个更大的排列，则反转该序列即可。

        // 如果只有一个数，那就没有调整的必要
        if(nums.length < 2){
            return;
        }

        int i = nums.length-2;
        while (i >= 0 && nums[i] >= nums[i+1]) {
            i--;
        }

        if(i==-1){
            // 说明已经是最大的排列了，没有更大的排序了
            // 这里sort的时间复杂度是：nlogn，但是因为其实已经是有序的了，只是需要反转一下，
            // 所以可以直接双指针调整，降低时间复杂度为：n
            // Arrays.sort(nums);
            int start = 0;
            int end = nums.length-1;
            while(start < end){
                int temp1 = nums[start];
                nums[start] = nums[end];
                nums[end] = temp1;
                start++;
                end--;
            }
            return;
        }

        // System.out.println("---" + i);
        // 走到这里，说明找到了降序的了
        // 需要把num[i]替换成i后面比num[i]次大的数字
        int numToReplace = nums[i];
        // 后面的数字都是降序的，所以从左到右找到第一个小于等于的数字，然后该数字左边的那个数字肯定是比num[i]次大的数字了
        int j = i+1;
        while (j < nums.length && nums[j] > numToReplace) {
            j++;
        }
        // 到这里说明已经找到了(如果中间没有break，最后的值是nums.length，会取出最后一个值，也不会有啥问题)
        // int biggerALitter = nums[j-1];

        // 这里替换掉
        int temp = nums[i];
        nums[i] = nums[j-1];
        nums[j-1] = temp;

        // 然后就是：把i后面的数字从小到大排列
        // i+1   --->   nums.length
        // 因为后面的数字都是有顺序的，只需要revert一下。
        int start = i+1;
        int end = nums.length-1;
        while(start < end){
            int temp1 = nums[start];
            nums[start] = nums[end];
            nums[end] = temp1;
            start++;
            end--;
        }
    }
}

代码解法2: 内部排序使用冒泡，先排序后交换拐点值

package com.shangguigu.dachang.algrithm.A01_arrays;

import java.util.Arrays;

/**
 * @author : 不二
 * @date : 2022/4/4-下午7:05
 * @desc :
 **/
public class A17_nextPermutation_by_bool {

    public static void main(String[] args) {
//         int[] nums = {4, 3, 2, 1};
//        int[] nums = {1, 1, 3, 4, 2, 0, -1};
        int[] nums = {1, 3, 2};
        nextPermutation(nums);
        System.out.println("结果是：" + Arrays.toString(nums));
    }

    public static void nextPermutation(int[] nums) {
        // 1, 从右往左找到第一个下降的点位置p1
        int p1 = -1;
        for (int i = nums.length - 1; i > 0; i--) {
            System.out.println(i);
            if (nums[i - 1] < nums[i]) {
                p1 = i-1;
                break;
            }
        }
        // 2, 如果没有下降点，说明是逆序排列组合，直接反转成正序即可
        if (p1 == -1) {
            for (int i = 0; i < nums.length/2; i++) {
                int tmp = nums[i];
                nums[i] = nums[nums.length-i-1];
                nums[nums.length-i-1] = tmp;
            }
            return;
        }

        // 3, 如果有下降点
        // System.out.println("第一个下降到数字是：" + p1 + "---" + nums[p1]);
        // 3.1, 然后对p1后的数据进行正序排序
        for (int i = p1 + 1; i < nums.length; i++) {
            // System.out.println("00000");
            for (int j = p1 + 1; j < nums.length - i -1 + p1 + 1; j++) {
                if(nums[j] > nums[j+1]){
                    int tmp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = tmp;
                }
                // System.out.println(Arrays.toString(nums) + "---" + j);
            }
        }

        // 3.2, 然后找到p1后第一个大于p1点的数据，替换即可
        for (int i = p1 + 1; i < nums.length; i++) {
            if(nums[i] > nums[p1]){
                int tmp = nums[i];
                nums[i] = nums[p1];
                nums[p1]  = tmp;
                // 第一次替换直接退出即可
                break;
            }
        }
    }
}