LeetCode-8-字符串转换整数_请你来实现-优快云博客

题目

请你来实现一个 myAtoi(string s) 函数，
使其能将字符串转换成一个 32 位有符号整数（类似 C/C++ 中的 atoi 函数）。

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

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

示例 1：

输入：s = "42"
输出：42
解释：加粗的字符串为已经读入的字符，插入符号是当前读取的字符。
第 1 步："42"（当前没有读入字符，因为没有前导空格）
         ^
第 2 步："42"（当前没有读入字符，因为这里不存在 '-' 或者 '+'）
         ^
第 3 步："42"（读入 "42"）
           ^
解析得到整数 42 。
由于 "42" 在范围 [-231, 231 - 1] 内，最终结果为 42 。

示例 2：

输入：s = "   -42"
输出：-42
解释：
第 1 步："   -42"（读入前导空格，但忽视掉）
            ^
第 2 步："   -42"（读入 '-' 字符，所以结果应该是负数）
             ^
第 3 步："   -42"（读入 "42"）
               ^
解析得到整数 -42 。
由于 "-42" 在范围 [-231, 231 - 1] 内，最终结果为 -42 。

示例 3：

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

示例 4：

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

示例 5：

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

接下来看一下解题思路：

方法一：

这道题目是字符串的转化问题，题中明确了转换的规则，所以我们需要根据不同的规则执行不同的动作。
主要有可以分为一下几步：

首先去掉前后空格；
判断第一个字符，如果是正负数符号，定义一个变量记录；
如果是数字转换为 int；如果是字符停止读取返回0；
如果是其它字符，需要判断，出现在首位则返回0；如果出现在字符串非首位，则返回值之前的结果；
题中对于转换为整数可能会出现溢出，所以需要判断：对于溢出的处理方式通常可以转换为 INT_MAX 的逆操作。比如判断某数乘以 10 是否会溢出，那么就把该数和 INT_MAX 除以 10 进行比较。

//硬写
public static int myAtoi1(String s) {
   // 去掉前后空格
   // 判断第一个字符，如果是正负数符号，定义一个变量记录；如果是数字转换为 int；如果是字符停止读取返回0；
   // 乘10 之前先判断是否溢出，如果溢出，返回边界值

   s = s.trim();

   char[] chars = s.toCharArray();
   int status = 1;
   int res = 0;

   for (int i = 0; i < chars.length; i++) {
       if (chars[i] == '-') { // 首位出现 -
           if(i != 0) { // 其它位出现 - 符号
               return res * status;
           }
           status = -1;
       } else if(chars[i] == '+') { // 首位出现 +
           if(i != 0) {  // 其它位出现 + 符号
               return res * status;
           }
           status = 1;
       } else if(chars[i] >= 48 && chars[i] <= 57) { // 处理数字情况
           int bigit = Integer.valueOf(chars[i] - '0');
           // 无论是正负数都按照整数来处理，然后根据首位的状态判断返回值，因为 整数的最大值绝对值小于最小值绝对值
           if(res > Integer.MAX_VALUE / 10 || (res == Integer.MAX_VALUE / 10 && bigit > 7)) {
               if (status > 0) {
                   return Integer.MAX_VALUE;
               }
               return Integer.MIN_VALUE;
           }
           res = (res * 10) + bigit;
       } else { // 处理其它字符情况
           if (i != 0) { // 非首位出现其它字符的情况
               return res * status;
           }
           return 0;
       }
   }
   return res * status;
}

时间复杂度：O(n)，其中 n 为字符串的长度。
空间复杂度：O(1)。只需要常数空间存储。

总结

上面的代码因为转换的规则比较多，所以写出来比较冗余，而且每个条件都是双重 if ，可读性差。

方法二状态转移法

看了官方的解题思路，发现可以用状态转移来实现。就是将不同的条件用不同的状态表示，使代码看起来明了。
首先将不同的条件通过一个字节的变量保存起来；
然后根据不同的状态执行不同的动作；
这里是通过 long 类型来保存结果的，所以可以做 int 的溢出判断；

// 状态转移
    public static int myAtoi(String s) {
        s = s.trim();

        // 初始状态为 0
        byte state = 0;
        // 记录正负状态，初始为正
        int sign = 1;
        // 保存结果
        long res = 0;

        // 0 表示初始状态
        // 1 表示字符串首位有 - 和 + 符号
        // 2 表示在状态 0 和 1 的情况下是数字的情况，并且可重入
        // 3 表示其它情况，直接返回
        for (int i = 0; i < s.length(); ++i) {
            char symbol = s.charAt(i);
            // 满足状态 1 条件
            if (state == 0 && (symbol == '-' || symbol == '+')) {
                state = 1;
            // 满足状态 2 条件
            } else if ((state == 0 || state == 1 || state == 2) && Character.isDigit(symbol)) {
                state = 2;
            // 其它情况，直接退出
            } else {
                state = 3;
            }
            //如果是状态 1 ，记录正负
            if (state == 1) {
                sign = (symbol == '-' ? -1 : 1);
            }
            // 状态 2 ，处理数字存储并且做边界的判断，因为是 long 类型保存的，所以可以验证 int 的溢出
            if (state == 2) {
                res = (res * 10) + (int)(symbol - '0');
                if (res * sign >= Integer.MAX_VALUE) {
                    return Integer.MAX_VALUE;
                }
                if (res * sign <= Integer.MIN_VALUE) {
                    return Integer.MIN_VALUE;
                }
            }
            if (state == 3) {
                break;
            }
        }
        // 将结果和符号位相乘得正负
        return (int)res != 0 ? (int)res * sign : 0;
    }

时间复杂度：O(n)，其中 n 为字符串的长度。
空间复杂度：O(1)。只需要常数空间存储。

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/string-to-integer-atoi/solution/zi-fu-chuan-zhuan-huan-zheng-shu-atoi-by-leetcode-/
来源：力扣（LeetCode）