LeetCode第八题: 字符串转换整数 (Java)

题目：字符串转换整数

实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数。

函数 myAtoi(string s) 的算法如下：

读入字符串并丢弃无用的前导空格
检查下一个字符（假设还未到字符末尾）为正还是负号，读取该字符（如果有）。 确定最终结果是负数还是正数。 如果两者都不存在，则假定结果为正。
读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
将前面步骤读入的这些数字转换为整数（即，"123" -> 123， "0032" -> 32）。如果没有读入数字，则整数为 0 。必要时更改符号（从步骤 2 开始）。
如果整数数超过 32 位有符号整数范围 [,   − 1] ，需要截断这个整数，使其保持在这个范围内。具体来说，小于  的整数应该被固定为  ，大于  − 1 的整数应该被固定为  − 1。
返回整数作为最终结果。
注意：

本题中的空白字符只包括空格字符 ' ' 。
除前导空格或数字后的其余字符串外，请勿忽略 任何其他字符。

示例：

输入：s = "4193 with words"
输出：4193
解释：
第 1 步："4193 with words"（当前没有读入字符，因为没有前导空格）
         ^
第 2 步："4193 with words"（当前没有读入字符，因为这里不存在 '-' 或者 '+'）
         ^
第 3 步："4193 with words"（读入 "4193"；由于下一个字符不是一个数字，所以读入停止）
             ^
解析得到整数 4193 。
由于 "4193" 在范围 [-231, 231 - 1] 内，最终结果为 4193 。




输入：s = "-91283472332"
输出：-2147483648
解释：
第 1 步："-91283472332"（当前没有读入字符，因为没有前导空格）
         ^
第 2 步："-91283472332"（读入 '-' 字符，所以结果应该是负数）
          ^
第 3 步："-91283472332"（读入 "91283472332"）
                     ^
解析得到整数 -91283472332 。
由于 -91283472332 小于范围 [-231, 231 - 1] 的下界，最终结果被截断为 -231 = -2147483648 

题目解读： 

给定一个字符串，对字符串依次进行如下操作。

第一步：去掉字符串前面的空格。

第二步：进行正负号判断

第三步：对剩下字符串循环，遇到非数字或到达字符串结尾退出循环。

当得到得整数超出边界，则按边界值截断

思路比较容易想到，循环判断，存储到一个int里。要注意边界，思路类似于第七题。

"0032" -> 32这种情况，存储在int中0032会自动变成32。

方法一：循环判断

这种方法比价容易想到，无非对字符串进行循环判断，输出最终结果。

 public static int myAtoi(String s) {
        //正负号标志，默认正号。
        int sign = 1;
        //存放最终的整形
        int res = 0;
        int i = 0;
        //去掉空格
        while (i < s.length() && s.charAt(i) == ' ') {
            i++;
        }
        //去掉前导空格后第一个字符的下标
        int start = i;
        for (; i < s.length(); i++) {
            char c = s.charAt(i);
            //正负号判断，注意 i == start ，去掉前导空格后下一个若是正负号才执行判断。
            //若忘记写 i == start ，字符串中正负号就不会 停止循环，违反题意（判断完正负，只要遇到非数字或结尾就结束循环）。
            if (i == start && c == '+') {
                sign = 1;
            } else if (i == start && c == '-') {
                sign = -1;
            } else if (Character.isDigit(c)) { //不是数字退出循环
                int num = c - '0';
                //边界判断
                if (res > Integer.MAX_VALUE / 10 || (res == Integer.MAX_VALUE / 10 && num > Integer.MAX_VALUE % 10)) {
                    return Integer.MAX_VALUE;
                }
                if (res < Integer.MIN_VALUE / 10 || (res == Integer.MIN_VALUE / 10 && -num < Integer.MIN_VALUE % 10)) {
                    return Integer.MIN_VALUE;
                }
                res = res * 10 + sign * num;
            } else {
                break;
            }
        }
        return res;
    }

这里对边界值进行下解释， Integer.MAX_VALUE = 2147483647

先解释下为什么不用 res * 10 + sign * num 直接进行边界判断？

会存在一种情况 res 符合边界，但 res * 10 + sign * num 后，已经超出边界res存储不下，他在强制给res赋值，res就会超出int的存储范围被截去。

res  > Integer.MAX_VALUE / 10 ，当 res > 214748364 时(比边界值少一位数)，不管res后面存储的数字是几，res都会大于边界值。例如 res = 214748365，尾数5后面不管数字是几，他都大于边界值。

res==Integer.MAX_VALUE/10&& num >Integer.MAX_VALUE%10，当res和Integer.MAX_VALUE/10相等时，res最后存放的一位数字一定要比Integer.MAX_VALUE最后一位数字小，res才不会超出边界。

负边界条件同理。

方法二：官方方法（自动机）

感觉不是特别适用这道题目，我第一反应一定不会这么思考，主要学习一下思想。

我感觉自动机有点像switch case，对于不同的条件，执行不同的语句或返回不同的状态。

声明四种状态，start初始状态，signed符号，in_number数字状态，end结束

每次循环不同的字符进入不同的状态。

直至end状态循环结束，输出结果。

	‘ ’	+/-	number	other
start	start	signed	in_number	end
signed	end	end	in_number	end
in_number	end	edn	in_number	end
end	edn	end	end	end

图换成表格感觉更加清晰。

public static int myAtoi(String str) {
        //初始化状态
        String status = "start";
        //ans定义为 long 可以防止溢出
        long ans = 0;
        //flag 代表 正负 初始化为正数 
        int flag = 1;
        char c;
        Map<String, String[]> table = new HashMap<>();
        table.put("start", new String[]{"start", "signed", "in_number", "end"});
        table.put("end", new String[]{"end", "end", "end", "end"});
        table.put("signed", new String[]{"end", "end", "in_number", "end"});
        table.put("in_number", new String[]{"end", "end", "in_number", "end"});
        for(int i = 0; i<str.length();i++){
            c = str.charAt(i);
            status = table.get(status)[get_col(c)];
            if ("signed".equals(status)) {
                flag = c == '+' ? 1 : -1;
                continue;
            }
            if ("in_number".equals(status)) {
                ans =  c - '0'+ ans*10;
                //边界情况
                ans = flag == 1 ? Math.min(ans, (long) Integer.MAX_VALUE) : Math.min(ans, -(long) Integer.MIN_VALUE);
            }
        }
        return (int)ans*flag;
    }

    public static int get_col(char c) {
        if (c == ' ') {
            return 0;
        }
        if (c == '+' || c == '-') {
            return 1;
        }
        if (Character.isDigit(c)) {
            return 2;
        }
        return 3;
    }

代码很容易看懂，把自动机放到map里。

总结

1. (res > Integer.MAX_VALUE / 10 || (res == Integer.MAX_VALUE / 10 && num > Integer.MAX_VALUE % 10

这种方式对 int 进行边界判断，可以学习

2.自动机这种思想，自动机存储到map里。感觉字符串可能会经常用到自动机。DFA和NFA

3.对于 int 边界问题，可以用long存储，超出边界则直接存储为边界值，最后强转。