LeetCode Top 100 Liked Questions 31. Next Permutation(Java版； Medium)

welcome to my blog

LeetCode Top 100 Liked Questions 31. Next Permutation(Java版; Medium)

题目描述

Implement next permutation, which rearranges numbers into the lexicographically next greater permutation of numbers.

If such arrangement is not possible, it must rearrange it as the lowest possible order (ie, sorted in ascending order).

The replacement must be in-place and use only constant extra memory.

Here are some examples. Inputs are in the left-hand column and its corresponding outputs are in the right-hand column.

1,2,3 → 1,3,2
3,2,1 → 1,2,3
1,1,5 → 1,5,1

class Solution {
    public void nextPermutation(int[] nums) {
        int n = nums.length;
        int i = n - 2;
        while(i>=0 && nums[i]>=nums[i+1]){
            i--;
        }
        if(i>=0){
            for(int j=n-1; j>=0; j--){
                //这里不能取等于
                if(nums[j] > nums[i]){
                    swap(nums, i, j);
                    break;
                    }
            }
        }
        reverse(nums, i+1);
    }

    private void swap(int[] nums, int i, int j){
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }

    private void reverse(int[] nums, int i){
        int j = nums.length - 1;
        while(i<j){
            swap(nums, i, j);
            i++;
            j--;
        }
    }
}

第一次做, 很费劲; 得考虑清楚判断条件是否取等; 核心: 从右向左遍历数组,找到第一队nums[i-1]<nums[i], 交换nums[i-1]和 num[j], 其中nums[j]>nums[i-1]&&nums[j-1]<nums[i], 从后往前找即可; 遍历方向要灵活; 逆序数组要写得精炼

/*
从右向左遍历, 找到nums[i] > nums[i-1]
*/
class Solution {
    public void nextPermutation(int[] nums) {
        if(nums==null || nums.length < 2)
            return;
        for(int i=nums.length-1; i>=0; i--){
            if(i==0){
                reverse(nums, 0, nums.length-1);
                break;
            }
            //这里是>=, 确保nums[i-1]<nums[i], 而不是nums[i-1]<=nums[i], 因为nums[i-1]==nums[i]的话, 程序会交换nums[i-1]和nums[i], 没有意义
            if(nums[i-1] >= nums[i])
                continue;
            int j = nums.length-1;
            //从后往前找到第一个比nums[i-1]大的数
            //这里必须得用>=, 不能只用>,  反例{1,5,1}, 只用>的话, 1会和1交换, 这是无效操作
            while(nums[i-1] >= nums[j])
                j--;
            swap(nums, i-1, j);
            reverse(nums, i, nums.length-1);
            break;
        }
    }
    public void swap(int[] arr, int i, int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    public void reverse(int[] arr, int i, int j){
        while(i<j){
            swap(arr, i++, j--);
        }
    }
}

题解, 代码结构更加合理

public class Solution {
    public void nextPermutation(int[] nums) {
        int i = nums.length - 2;
        while (i >= 0 && nums[i + 1] <= nums[i]) {
            i--;
        }
        if (i >= 0) {
            int j = nums.length - 1;
            while (j >= 0 && nums[j] <= nums[i]) {
                j--;
            }
            swap(nums, i, j);
        }
        reverse(nums, i + 1);
    }

    private void reverse(int[] nums, int start) {
        int i = start, j = nums.length - 1;
        while (i < j) {
            swap(nums, i, j);
            i++;
            j--;
        }
    }

    private void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}