LeetCode 670. Maximum Swap

问题描述

Given a non-negative integer, you could swap two digits at most once to get the maximum valued number. Return the maximum valued number you could get.

Example 1:

Input: 2736
Output: 7236
Explanation: Swap the number 2 and the number 7.

Example 2:

Input: 9973
Output: 9973
Explanation: No swap.
Note:
The given number is in the range [0, 108]

问题分析

这个题目是只允许一次交换次序，使得这个数到达能够得到最大的数。
最大的情况是当前这个数中的数字，大的数在高位，一次排列下去。
使用一个数，对当前的数进行排序，然后一次比较第一个不同的。然后从后往前找，找到第一个大的数就好。例如98368 排好序是 98863 这个时候一比较发现 8 和3 进行交换。然后从后往前找到了最后一位上的 8 然后交换两个的位置。得到一个最终的值。

代码实现

/**
     * 给定一个非负数,交换这个数中的两位,得到最大的数。
     *
     * @param num
     * @return
     */
    public int maximumSwap(int num) {

        if (num <= 0) {
            return num;
        }
        List<Integer> nums = transToArray(num);
        ArrayList<Integer> copyNums = new ArrayList<Integer>(nums);

        Collections.sort(copyNums);

        //从高位想低位找,找到第一个不同的位置

        int differentIndex = nums.size() - 1;
        while (differentIndex >= 0) {
            if (nums.get(differentIndex) != copyNums.get(differentIndex)) {
                break;
            }
            differentIndex--;
        }
        if (differentIndex < 0) {
            return num;
        } else {
            //从低位开始找,找到第一个不同的数,然后进行交换

            for (int i = 0; i < nums.size(); i++) {
                if (copyNums.get(differentIndex) == nums.get(i)) {
                    swap(nums, differentIndex, i);
                    break;
                }
            }
        }
        int transNum = transToNum(nums);
        return transNum;
    }

    /**
     * 将一个正数变成一个数组
     *
     * @param num
     * @return
     */
    protected List<Integer> transToArray(int num) {

        int base = 10;
        List<Integer> nums = new ArrayList<Integer>();
        while (num > 0) {
            nums.add(num % base);
            num = num / base;
        }
        return nums;

    }

    /**
     * 交换两个数的位置
     *
     * @param nums
     * @param firstIndex
     * @param secondIndex
     */
    private void swap(List<Integer> nums, int firstIndex, int secondIndex) {
        int tem = nums.get(firstIndex);
        nums.set(firstIndex, nums.get(secondIndex));
        nums.set(secondIndex, tem);
    }


    /**
     * 将一个数组变成一个数
     *
     * @param nums 数组
     * @return
     */
    protected int transToNum(List<Integer> nums) {
        int base = 1;
        int result = 0;
        for (int num : nums) {
            result += num * base;
            base = base * 10;
        }
        return result;
    }

实现改进

之前的算法的空间复杂度是O(N)，时间复杂度是O（nlogn）。这里只要将尽可能大的数往前调换。记录没一个数字最后出现的位置（最低位）。然后每一位看一下有没有更大的数在跟低位出现。一位只交换一次，所以可以只记录一次。

算法实现

 public int maximumSwap(int num) {

        if (num <= 0) {
            return num;
        }
        char[] chars = String.valueOf(num).toCharArray();
        int[] digitalCount = new int[10];
        for (int i = 0; i < chars.length; i++) {
            digitalCount[chars[i] - '0'] = i;//记录0-9 最后一次出现的次数
        }
        for (int i = 0; i < chars.length; i++) {
            for (int j = 9; j > chars[i] - '0'; j--) {
                if (digitalCount[j] > i) {
                    char temp = chars[i];
                    chars[i] = chars[digitalCount[j]];
                    chars[digitalCount[j]] = temp;
                    String s = new String(chars);
                    return Integer.parseInt(s);
                }
            }

        }
        return num;
    }