算法(TS)：字符串转换整数 (atoi)

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

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

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

注意：

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

示例

示例 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 。

提示：

0 <= s.length <= 200

解答

定义一个数组 nums 用来保存构成结果的有效字符。

第一步：遍历 s，将构成结果的字符push 到 nums 中
第二步：遍历 nums，用科学记数法得到最终的结果，比如 nums 的值为 [3,4,5]，那么得到的结果是 3 * Math.pow(10,2) + 4 * Math.pow(10,1) + 5 * Math.pow(10,0)
第三步：将第二步得到的结果与 Math.pow(2,31) -1 和 Math.pow(-2,31)

typescript 复制代码

function myAtoi(s: string): number {
    const nums: string[] = []
    
    for(let i = 0; i < s.length; i++) {
        const val = s[i]
        if (nums.length === 0 && /[-+]/.test(val)) {
            nums.push(val)
            continue
        }
        
        if (val === ' ' && nums.length === 0) {
            continue
        }

        if (!/^[0-9]/.test(val)) {
            break
        }

        nums.push(val)
    }

    if (nums.length === 0) {
        return 0
    }

    let baseNumber: number = nums[0] === '-' ? -1 : 1
    let result = 0

    for(let i = /[-+]/.test(nums[0]) ? 1: 0; i < nums.length; ++i) {
        const num = Number(nums[i])
        result += baseNumber * num * Math.pow(10,nums.length - i - 1)
    }

    const max = Math.pow(2,31) -1
    const min = Math.pow(-2,31)
    if (result > max) {
        return max
    }

    if (result < min) {
        return min
    }

    return result
};

空间复杂度O(n)，时间复杂度O(n)

解答二

定义 re 为最终返回的结果，遍历 s，判断组成结果的字符，利用公式 re = re * 10 + (-1/1) * Number(s[i])

ini 复制代码

function myAtoi(s: string): number {
    let re: number = 0
    let baseNumber: number | undefined = undefined
    const max = Math.pow(2,31) -1
    const min = Math.pow(-2,31)
    
    for(let i = 0; i < s.length; i++) {
        const val = s[i]
        if (val === ' ' && baseNumber === undefined) {
            continue
        }

        if (val === '-' && baseNumber === undefined) {
            baseNumber = -1
            continue
        }

        if (val === '+' && baseNumber === undefined) {
            baseNumber = 1
            continue
        }

        if (!/^[0-9]/.test(val)) {
            break
        }

        
        if (baseNumber === undefined) {
            baseNumber = 1
        }
        
        re = re * 10 + baseNumber * Number(val)
        
        if (re > max) {
            re = max
            break
        }

        if (re < min) {
            re = min
            break
        }
        
    }
  
    return re
};

时间复杂度(n)，空间复杂度 O(1)