字符串转整数 (atoi)

最新推荐文章于 2022-12-14 12:32:09 发布

chuju7857

最新推荐文章于 2022-12-14 12:32:09 发布

阅读量141

点赞数

文章标签：测试

原文链接：https://my.oschina.net/u/3973880/blog/2207247

版权

题目：

实现 atoi，将字符串转为整数。

该函数首先根据需要丢弃任意多的空格字符，直到找到第一个非空格字符为止。如果第一个非空字符是正号或负号，选取该符号，并将其与后面尽可能多的连续的数字组合起来，这部分字符即为整数的值。如果第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成整数。

字符串可以在形成整数的字符后面包括多余的字符，这些字符可以被忽略，它们对于函数没有影响。

当字符串中的第一个非空字符序列不是个有效的整数；或字符串为空；或字符串仅包含空白字符时，则不进行转换。

若函数不能执行有效的转换，返回 0。

说明：

假设我们的环境只能存储 32 位有符号整数，其数值范围是 [−231, 231 − 1]。如果数值超过可表示的范围，则返回 INT_MAX (231 − 1) 或 INT_MIN (−231) 。

示例 1:

输入: "42"
输出: 42

示例 2:

输入: "   -42"
输出: -42
解释: 第一个非空白字符为 '-', 它是一个负号。
     我们尽可能将负号与后面所有连续出现的数字组合起来，最后得到 -42 。

示例 3:

输入: "4193 with words"
输出: 4193
解释: 转换截止于数字 '3' ，因为它的下一个字符不为数字。

示例 4:

输入: "words and 987"
输出: 0
解释: 第一个非空字符是 'w', 但它不是数字或正、负号。
     因此无法执行有效的转换。

示例 5:

输入: "-91283472332"
输出: -2147483648
解释: 数字 "-91283472332" 超过 32 位有符号整数范围。 
     因此返回 INT_MIN (−231) 。

这道题目需要很认真的去审题，我之前实现的方法和题目描述的得到的结果并不一致，所以再三审题，才把想要输出什么搞清楚。

我的思路：

* 1、判断数组长度，数组长度为0，返回0；否侧进行2
* 2、判断数组第一个非空字符是否是数字或者是'-'字符，不满足条件则返回0；满足则进行3
* 3、如果第一个非空字符是'-'字符，那么判断它后续的字符是否是数字，如果不是，则返回0；如果是数字，则获取连续数字串，直到取到其他字符或者遍历到最后一个字符
* 4、如果第一个非空字符是数字，则获取连续数字串，直到取到其他字符或者遍历到最后一个字符
* 5、对于3和4取到的字符进行判断，看其值是否越界，越界则返回上下界的值，否则返回其本身。

代码：

class Solution {
    public int myAtoi(String str) {
        //1
        if (str.length() == 0 ){
            return 0;
        }

        //2 获得第一个非空字符
        char firstNotNull = ' ';
        for ( int i = 0; i < str.length(); i++){
            if (str.charAt(i) != ' '){
                firstNotNull = str.charAt(i);
                break;
            }
        }

        //计算-字符的数量，如果-字符数量等于字符串长度返回0
        int fucount = 0;
        for ( int i = 0 ; i < str.length(); i++){
            if (str.charAt(i) == '-' || str.charAt(i) == '+'){
                fucount ++;
            }
        }
        if (fucount == str.length()){
            return 0;
        }

        //3
        StringBuilder sb = new StringBuilder();
        long res = 0;
        if ( !Character.isDigit(firstNotNull) && (firstNotNull != '-') &&(firstNotNull!= '+')){
            return 0;

        }else if ( Character.isDigit(firstNotNull) ){
            for (int i = str.indexOf(firstNotNull); i < str.length(); i++){
                if ( Character.isDigit(str.charAt(i)) ){
//                    System.out.println("i: "+i);
//                    System.out.println("first: "+firstNotNull);
                    sb.append(str.charAt(i));
                }else{
                    break;
                }
            }
//            System.out.println(sb);
            if (sb.toString().length() == 0){
                return 0;
            }
            //计算出0打头的数的长度不超过MAX_VALUE,把0全部去掉之后的长度不能大于10
            int beginZero = 0;
            for (int i = 0; i < sb.toString().length(); i++){
                if (sb.toString().charAt(i) == '0'){
                    beginZero++;
                }else {
                    break;
                }
            }
            if ( (sb.toString().length() - beginZero)>11){
                return Integer.MAX_VALUE;
            }
            res = Long.parseLong(sb.toString());
            if (res >= Integer.MAX_VALUE){
                return Integer.MAX_VALUE;
            }else {
                return (int) res;
            }
        }else if ( firstNotNull == '-' ){
            sb.append('-');
            if (firstNotNull != str.length() -1) {
                for (int i = str.indexOf(firstNotNull)+1; i < str.length(); i++) {
                    if ( Character.isDigit(str.charAt(i)) ){
                        sb.append(str.charAt(i));
                    }else{
                        break;
                    }
                }

                int fucount2 = 0;
                for ( int i = 0 ; i < sb.toString().length(); i++){
                    if (sb.toString().charAt(i) == '-'){
                        fucount2 ++;
                    }
                }
                if (fucount2 == sb.toString().length()){
                    return 0;
                }

                if (sb.toString().length() == 0){
                    return 0;
                }

                //计算出0打头的数的长度不超过MAX_VALUE,把0全部去掉之后的长度不能大于10
                int beginZero = 0;
                for (int i = 1; i < sb.toString().length(); i++){
                    if (sb.toString().charAt(i) == '0'){
                        beginZero++;
                    }else {
                        break;
                    }
                }
                if ( (sb.toString().length() - beginZero)>11){
                    return Integer.MIN_VALUE;
                }

                res = Long.parseLong(sb.toString());
                if (res <= Integer.MIN_VALUE){
                    return Integer.MIN_VALUE;
                }else {
                    return (int) res;
                }
            }else{
                return 0;
            }
        }else if ( firstNotNull == '+'){
            sb.append('+');
            if (firstNotNull != str.length() -1) {
                for (int i = str.indexOf(firstNotNull)+1; i < str.length(); i++) {
                    if ( Character.isDigit(str.charAt(i)) ){
                        sb.append(str.charAt(i));
                    }else{
                        break;
                    }
                }

                if (sb.toString().length() == 1){
                    return 0;
                }

                int fucount2 = 0;
                for ( int i = 1 ; i < sb.toString().length(); i++){
                    if (sb.toString().charAt(i) == '+'){
                        fucount2 ++;
                    }
                }
                if (fucount2 == sb.toString().length()){
                    return 0;
                }

                if (sb.toString().length() == 0){
                    return 0;
                }

                //计算出0打头的数的长度不超过MAX_VALUE,把0全部去掉之后的长度不能大于10
                int beginZero = 0;
                for (int i = 0; i < sb.toString().length(); i++){
                    if (sb.toString().charAt(i) == '0'){
                        beginZero++;
                    }else {
                        break;
                    }
                }
                if ( (sb.toString().length() - beginZero)>11){
                    return Integer.MAX_VALUE;
                }
                res = Long.parseLong(sb.toString());
                if (res >= Integer.MAX_VALUE){
                    return Integer.MAX_VALUE;
                }else {
                    return (int) res;
                }
            }else{
                return 0;
            }
        }
        return (int) res;
    }
}

具体是实现过程中，有很多细节设计不足，一次次根据测试用例未通过报出的bug，来调整代码逻辑，花了很长时间才通过1079个测试用例。

然而执行速度可想而知，逻辑磕磕碰碰地最后完成了题意。

参考他人的思路：

class Solution {
    public int myAtoi(String str) {
        str = str.trim();
        if (str.isEmpty()) {
            return 0;
        }
        int sign = 1;
        long base = 0;
        int i = 0;
        if (str.charAt(i) == '+' || str.charAt(i) == '-') {
            sign = str.charAt(i) == '+' ? 1 : -1;
            i++;
        }
        while (i < str.length() && str.charAt(i) >= '0' && str.charAt(i) <= '9') {
   
            base = base * 10 + (str.charAt(i) - '0');
            if (base > Integer.MAX_VALUE) {
                return sign == 1 ? Integer.MAX_VALUE : Integer.MIN_VALUE;
            }
            i++;
        }
        return ((int)base) * sign;
        
    }
}

思路：

1、将str首位空字符去掉

2、如果str为空，返回0；否则，进行3

3、用一个标识sign来表示正负，用一个long base来存储字符串内的数值，

4、判断第一个字符是否为“-”或“+”号，如果是，则i++，i进到下一位

5、判断i所在位置是否等于大于字符串大小，如果大于等于，则不进入while；

判断字符在i的位置是否是数字，如果不是数字，则不进入while；是数字，进入while，用base = base*10 + (str.charAt(0) - '0');的方式得到base，判断是否越界，i进入下一位继续判断是否为是数字。

这段代码逻辑很清晰，巧用+-1来判断正负，用i作为判断是否是数字的一个标志。

其实一开始我也想用trim方法的，但是可能由于逻辑杂乱，代码速度太慢，导致使用trim总是报超时，所以又自己实现了一个方法去得到第一个元素的值。

转载于:https://my.oschina.net/u/3973880/blog/2207247

chuju7857

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
字符串转整数 (atoi)

题目：实现atoi，将字符串转为整数。该函数首先根据需要丢弃任意多的空格字符，直到找到第一个非空格字符为止。如果第一个非空字符是正号或负号，选取该符号，并将其与后面尽可能多的连续的数字组合起来，这部分字符即为整数的值。如果第一个非空字符是数字，则直接将其与之后连续的数字字符组合...
复制链接

扫一扫