LeetCode-String to Integer (atoi)的一种算法

LeetCode-String to Integer (atoi)的一种算法

题目链接：https://leetcode.com/problems/string-to-integer-atoi/description/

Implement atoi which converts a string to an integer.

The function first discards as many whitespace characters as necessary until the first non-whitespace character is found. Then, starting from this character, takes an optional initial plus or minus sign followed by as many numerical digits as possible, and interprets them as a numerical value.

The string can contain additional characters after those that form the integral number, which are ignored and have no effect on the behavior of this function.

If the first sequence of non-whitespace characters in str is not a valid integral number, or if no such sequence exists because either str is empty or it contains only whitespace characters, no conversion is performed.

If no valid conversion could be performed, a zero value is returned.

Note:

Only the space character ’ ’ is considered as whitespace character.
Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [−231, 231 − 1]. If the numerical value is out of the range of representable values, INT_MAX (231 − 1) or INT_MIN (−231) is returned.

Example 1:
Input: “42”
Output: 42

Example 2:
Input: " -42"
Output: -42
Explanation: The first non-whitespace character is ‘-’, which is the minus sign.
Then take as many numerical digits as possible, which gets 42.

Example 3:
Input: “4193 with words”
Output: 4193
Explanation: Conversion stops at digit ‘3’ as the next character is not a numerical digit.

Example 4:
Input: “words and 987”
Output: 0
Explanation: The first non-whitespace character is ‘w’, which is not a numerical
digit or a +/- sign. Therefore no valid conversion could be performed.

Example 5:
Input: “-91283472332”
Output: -2147483648
Explanation: The number “-91283472332” is out of the range of a 32-bit signed integer.
Thefore INT_MIN (−231) is returned.

由题意可知，给出一个字符串，要求我们从中找到一串数字并转换为整形。
需要注意的是，空格字符当作不存在，数字前可存在正负号，除此之外不可存在任何别的字符。换而言之，就是从第一位开始找到由空格、正负号和数字等组成的一段字符串，并将这一段字符转换为整形。
同时，还要检测转换的整形是否溢出，若溢出，返回其边界值。

算法如下

class Solution {
public:
    int myAtoi(string str) {
        int len = str.length();
        //寻找第一个非空格的字符位置
        int flag;
        for (flag = 0; str[flag] == ' '; flag++) {
            if (flag == len-1) {
                return 0;
            }
        }
        //判断第一个非空格的字符是否正负号或者数字
        string temp = str.substr(flag, len);
        //判断为正负号和数字，转换字符串
        if (temp[0] == '-'||temp[0] == '+') {
            int num = getNum(temp, 1, len);
            return num;
        }
        else if (temp[0] <= '9' && temp[0] >= '0') {
            int num = getNum(temp, 0, len);
            return num;
        }
        //判断为其他字符，直接返回0值
        else {
            return 0;
        }
    }
    
    //字符串转换整形函数
    int getNum(string str, int pos, int len) {
        int i;
        long re;
        //找到非空格位置
        int flag;
        for (flag = 0; str[flag] == ' '; flag++) {
            if (flag == len-1) {
                return 0;
            }
        }
        string temp = str.substr(flag, len);
        //找到连续数字的字符串的末尾位置
        for (i = pos; i < len; i++) {
            if (temp[i] > '9' || temp[i] < '0') {
                break;
            }
        }
        string restr = temp.substr(flag, i);
        //转换为整形
        stringstream ss;
        ss << restr;
        ss >> re;
        //判断溢出与否
        if (re > INT_MAX) return INT_MAX;
        if (pos == 1&&re < INT_MIN) return INT_MIN;
        return re;
    }
};

---

该算法尽管使用了三个循环，但是本质上只是对一个字符串进行一次循环遍历，只是把这个遍历分为寻找正负号、寻找连续数字字符、寻找结束位置三个阶段而已，所以种的时间复杂度为O(n)。