LeetCode刷题之旅（简单-15）：加一

2019年6月11日

目录

题目：

错误思路：数据类型转换，运算

解决方法1：递归检测进位

思路：

性能结果：

解决方法2：思路简洁的解法

思路：

性能结果：

小结：

---

 

题目：

 

错误思路：数据类型转换，运算

    public static int[] plusOne(int[] digits) {
        // 1.数组转string
        StringBuilder numString = new StringBuilder();
        for (int i : digits){
            numString.append(i);
        }

        // 2.string转int并加1
        Long num = Long.valueOf(numString.toString()) + 1;

        // 3.逐个拆解字符，并转数组
        char[] numChars = num.toString().toCharArray();
        int[] result = new int[numChars.length];
        for (int i=0;i<numChars.length;i++){
            result[i] = Integer.parseInt(String.valueOf(numChars[i]));
        }
        return result;
    }

• 完美错过题目的意思。

 

解决方法1：递归检测进位

public class PlusOne {

    public static void main(String[] args){
        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(6);
        integers.add(8);
        integers.add(3);
        integers.add(5);
        integers.add(9);
        int[] nums = integers.stream().mapToInt(Integer::intValue).toArray();
        int[] result = plusOneV2(nums);
        System.out.println("result="+result.toString());
    }

    public static int[] plusOneV2(int[] digits){
        int length = digits.length;
        int index = length-1;
        int[] result = new int[digits.length+1];
        result = plueOneForArray(digits, index);
        return result;
    }

    public static int[] plueOneForArray(int[] array,int index){
        int[] result = array;
        if (array[index] +1 < 10){
            // 1、普通加一，无需进位
            array[index] = array[index] + 1;
        }else {
            // 2、普通加一，需要进位
            array[index] = 0;
            if (index > 0){
                result = plueOneForArray(array, index - 1);
            }else {
                // 3、进位超出原来长度，重新申请空间
                result = new int[array.length + 1];
                result[0] = 1;
                for (int i = 1;i<result.length;i++){
                    result[i] = array[i-1];
                }
            }
        }
        return result;
    }

}

 

思路：

• 将重复性的操作，封装到同一个方法里，然后对不同情况进行处理；

 

性能结果：

解决方法2：

class Solution {
    public int[] plusOne(int[] digits) {
        for (int i = digits.length - 1; i >= 0; i--) {
            digits[i]++;
            digits[i] = digits[i] % 10;
            if (digits[i] != 0) return digits;
        }
        digits = new int[digits.length + 1];
        digits[0] = 1;
        return digits;
    }
}

思路：

• 很简洁的方法，就是每个位置上的数自增然后%10取模，为0表示进位；
• 从末尾开始遍历，O（n）的时间复杂度；

性能结果：

 

小结：

还是比较轻松的一道题，虽然一开始没理解题意，但后面捋顺思路，挺好解决的。