将字符串转化为整数

class Solution {
public:
    int atoi(const char *str) {
        if(*str=='\0') return 0;
        const char* p =str;
        while(*p==' ') ++p;
        int sign=1;
        if(*p=='+' ||*p=='-') sign=(*p++=='+')?1:-1;
        long res=0;
        while(isdigit(*p)){
            res=res*10+(*p++)-'0';
            if(res*sign>=INT_MAX) return INT_MAX;
            if(res*sign<=INT_MIN) return INT_MIN;
        }
        return res*sign;
    }
};

public class Demo1 {
	/*
	 * [leetcode]8. String to Integer (atoi)
	 * 该题需要考虑的几个关键点：1.正负号；2.中间存在字母（只取字母前的数字）;3.溢出;4.前后空格
	 * 
	 * Integer.Min_VALUE=-2147483648 . Integer.MAX_VALUE=2147483647
	 */
	public static int myAtoi(String str) {
		if (str == null || str.trim().length() < 1)
			return 0;
		//处理掉前后空格
		char[] arr = str.trim().toCharArray();

		int sign = 1, index = 0;
		//判断正负号
		if (arr[0] == '+')
			index++;
		if (arr[0] == '-') {
			sign = -1;
			index++;
		}

		int num = 0;
		for (int i = index; i < arr.length; i++) {
			if (arr[i] - '0' >= 0 && arr[i] - '9' <= 0) {
				//如果当前运算会越界的时候，直接输出结果
				if (num > Integer.MAX_VALUE / 10 || num == Integer.MAX_VALUE / 10 && arr[i] - '7' > 0) {
					if (sign > 0)
						return Integer.MAX_VALUE;
					else
						return Integer.MIN_VALUE;
				}

				num = 10 * num + arr[i] - '0';
			} else
				//如果是字母，跳出循环
				break;
		}

		return num * sign;
	}
}

import java.util.*;


public class Solution {
    /**
     * 
     * @param str string字符串 
     * @return int整型
     */
    public int atoi (String str) {
        // write code here
        String temp = str.trim();
        if(temp.equals("")){
            return 0;
        }
        char[] chs = temp.toCharArray();
        int i = 0;
        for(;i < chs.length; i++){
            if(chs[i]!='+' && chs[i]!='-' && (chs[i]<'0' || chs[i]>'9')){
                break;
            }
        }
        // 使用try-catch做出溢出判断
        try{
            return Integer.valueOf(temp.substring(0,i));
        }catch(Exception e){
            if(temp.charAt(0)=='-'){
                return Integer.MIN_VALUE;
            }else{
                return Integer.MAX_VALUE;
            }
        }
    }
}

/**
 * 
 * @author ChopinXBP
 * 请你来实现一个 atoi 函数，使其能将字符串转换成整数。
 * 首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。
 * 当我们寻找到的第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字组合起来，作为该整数的正负号；
 * 假如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成整数。
 * 该字符串除了有效的整数部分之后也可能会存在多余的字符，这些字符可以被忽略，它们对于函数不应该造成影响。
 * 注意：假如该字符串中的第一个非空格字符不是一个有效整数字符、字符串为空或字符串仅包含空白字符时，则你的函数不需要进行转换。
 * 在任何情况下，若函数不能进行有效的转换时，请返回 0。
 * 说明：
 * 假设我们的环境只能存储 32 位大小的有符号整数，那么其数值范围为 [−231,  231 − 1]。如果数值超过这个范围，qing返回  INT_MAX (231 − 1) 或 INT_MIN (−231) 。
 *
 */

public class StringtoInteger {
    public static void main(String[] args) {
        System.out.println(StrToInt("+2147483647"));
        System.out.println(StrToInt("   -42"));
        System.out.println(StrToInt("4193 with words"));
        System.out.println(StrToInt("words and 987"));
        System.out.println(StrToInt(" "));
        System.out.println(StrToInt("-91283472332"));
        System.out.println(StrToInt("10000000000000000000000000000000000000000000000000000000000000000522545459"));
        System.out.println(StrToInt("00000000000000000000000000000000000000000000000000000000000000000522545459"));
    }
    
    public static int StrToInt(String str) {
        int end = str.length();
        if(end == 0) return 0;
                 long result = 0;
        long loc = 1;
        int begin = 0;
        boolean ispositive = true;
                 //跳过起始的空格
        while(begin < end && str.charAt(begin) == ' ') {
            begin++;
        }
                     if(begin < end && str.charAt(begin) == '+') {
            begin++;
        }
        else if(begin < end && str.charAt(begin) == '-') {
            ispositive = false;
            begin++;
        }
                 //end指向第一个非数字字符，此时begin-end之间应为纯数字
        for(int i = begin; i < str.length(); i++) {
            if(!isNum(str.charAt(i))){
                end = i;
                break;
            }
        }
                 int idx = 0;             while(begin < end) {
            //判断是否为数字
            if(!isNum(str.charAt(end - 1))) return 0;
            if(idx > 10) {
                //排除过分溢出情况,如最后一个测试用例
                if(str.charAt(end - 1) != '0' && ispositive) {
                    return Integer.MAX_VALUE;
                }else if(str.charAt(end - 1) != '0' && !ispositive) {
                    return Integer.MIN_VALUE;
                }
            }

            result += Integer.parseInt(str.charAt(end - 1) + "") * loc;
            //判断溢出
            if(result > 0x7fffffff && ispositive) {
                return Integer.MAX_VALUE;
            }else if(result > 0x7fffffff && !ispositive){
                return Integer.MIN_VALUE;
            }
            loc *= 10;
            end--;
            idx++;
        }
                        if(ispositive) {
            return (int)result;
        }else {
            return -(int)result;
        }
             }
    
    public static boolean isNum(char c){
        if(c >= '0' && c <= '9') {
            return true;
        }else {
            return false;
        }
    }

}

	



	



	



	

class Solution {
public:
  int atoi(const char *str) {
    if (!*str) return 0; // "" == return 0;
    while (*str && *str == 32) ++str; // 跳过所有的前导空格
    
    int sign = 1; // + == 1, - == -1
    if (*str == '+') {
      ++str;
    } else if (*str == '-') {
      sign = -1;
      ++str;
    }
    
    long n = 0;
    while (*str) {
      if (not isdigit(*str)) return sign * n;
      n = n * 10 + *str++ - 48;
      if (sign == 1 && n > INT_MAX) return INT_MAX;
      if (sign == -1 && -n < INT_MIN) return INT_MIN;
    }
    
    return sign * n;
  }
};

import java.util.*;


public class Solution {
    /**
     * 
     * @param str string字符串 
     * @return int整型
     */
    public int atoi (String str) {
        // write code here
        StringBuilder sb = new StringBuilder();
        char[] ch = str.trim().toCharArray();
        for(int i=0; i<ch.length; i++){
            if(i==0 && (ch[i]=='-' || ch[i]=='+')){
                sb.append(ch[i]);
                continue;
            }
            if(ch[i]>='0' && ch[i]<='9'){
                sb.append(ch[i]);
            }else{
                break;
            }
        }
        if(sb.length()>0){
            long l = Long.parseLong(sb.toString());
            if(l >= Integer.MAX_VALUE){
                return Integer.MAX_VALUE;
            }else if(l <= Integer.MIN_VALUE){
                return Integer.MIN_VALUE;
            }
            return Integer.parseInt(sb.toString());
        }
        return 0;
    }
}

这道题目玄之又玄，大家记住步骤就好啦：

1. 处理空字符串
2. 忽略前置空格
3. 保存符号
4. 处理非法输入
5. 处理溢出

多想无益，就住就行了。

class Solution {
public:
    int atoi(const char *str) {
        int idx = 0, sign = 1, val = 0;
        // 1. 空字符串
        if (strlen(str) == 0) return 0;
        // 2. 忽略前置0
        while (str[idx] == ' ') ++idx;
        // 3. 记录符号
        if (str[idx] == '-') {sign = -1; ++idx;}
        if (str[idx] == '+') {++idx;}
        for (; idx < strlen(str); ++idx) {
            // 4. 处理非法值
            if (str[idx] < '0' || str[idx] > '9') break;
            // 5. 处理溢出
            if (val > INT32_MAX / 10 || (val == INT32_MAX / 10 && INT32_MAX % 10 < str[idx] - '0')) {
                return sign == 1 ? INT32_MAX : INT32_MIN;
            }
            val = val * 10 + str[idx] - '0';
        }
        return val * sign;
    }
};

    /*
    * 目的：实现函数 atoi
    * 注意：
    * 1.前面可能有空格
    * 2.可能含有正负号
    * 3.可能超过int的范围
    * 4.如果含有非法字符，将非法字符前面的数字返回
    */
    int atoi(const char *str) {
        long res = 0;
        int b = false;
        if (str==nullptr)
            return 0;
        while(*str==' '){
            str++;
        }
        if (*str=='-'){
            b = true;
            str++;
        }
        else if (*str== '+'){
            b= false;
            str++;
        }
        while(*str!='\0'){
            if (*str>='0'&& *str<='9'){
                res = res*10 + *str-'0';
                str++;
                if (res>INT_MAX)
                    return b?INT_MIN:INT_MAX;
            }
            else{
                return b?-res:res;
            }
        }
        return b?-res:res;
    }

int atoi(const char* str) {
     if (str == NULL) return 0;
 
     int res = 0, flag = 1;
     auto *p = str;  // str 为常指针
 
     // 跳过前面的空格
     while (isspace(*p)) p++;
 
     // 判断正负
     if (*p == '-') flag = -1;
     if (*p == '-' || *p == '+') p++;
 
     // 首个非空字符不是数字，注意与判断正负的顺序
     // if (*p < '0' && *p > '9') return 0;       // 不需要
 
     // 循环转换整数（核心代码）加入溢出判断
     while (*p >= '0' && *p <= '9') {
         int new_res = res * 10 + (*p - '0');
         if (new_res / 10 != res) {
             return flag > 0 ? INT_MAX : INT_MIN;
         }
         res = new_res;
         p++;
     }
     // 无溢出判断
     /*while (*p >= '0' && *p <= '9') {
         res = res * 10 + (*p - '0');
         p++;
     }*/
     return res * flag;
 }

int myAtoi(string str) {
     if(str.size() < 1) return 0;
     int flag = 1, i = 0;
     //先过滤空格
     while(isspace(str[i]))
         ++i;
     if(str[i] == '-' || str[i] == '+'){
         if(str[i] == '-') flag = -1;
         ++i;
     }
     long long res = 0;
     if(isdigit(str[i])){
         while (isdigit(str[i])) {
             res = res*10 + (str[i] - '0');
             if(flag*res > INT_MAX) return INT_MAX;
             if(flag*res < INT_MIN) return INT_MIN;
             ++i;
             //if(i > 9)第一次想法是这样判断溢出
             //    break;但用位数无法判断"  0000000000012345678"
         }
     }
     else
         return 0;
     return flag*res;
 }

class Solution {
public:
    int atoi(const char *str) {
        int i;
        for(i=0;str[i]!='\0'&&str[i]==' ';i++);
        if(str[i]=='\0') return 0;
        char s[1000000];
        strcpy(s,str+i);
        for(i=1;'0'<=s[i]&&s[i]<='9';i++);
        s[i]='\0';
        if(!judge(s)) return 0;
        int len=(int)strlen(s);
        if(len>=12){
            if(s[0]=='-') return -2147483648;
            return 2147483647;
        }
        long long a=(long long)atof(s);
        if(a<0&&s[0]!='-') return 2147483647;
        if(a>0&&s[0]=='-') return -2147483648;
        if(a>=2147483647) return 2147483647;
        if(a<=-2147483648) return -2147483648;
        return (int)a;
    }
    bool judge(char *str){
        int len=strlen(str);
        if(len==1&&(str[0]<'0'||str[0]>'9')) return false;
        if('0'>str[0]||str[0]>'9')
            if(str[0]!='+'&&str[0]!='-') return false;
        for(int i=1;str[i]!='\0';i++)
            if('0'>str[i]||str[i]>'9') return false;
        return true;
    }
};//这题写得我想死.....

class Solution {
public:
/// 函数库 stoi的编写：主要考虑空白字符、正负号、溢出、非法字符停止等条件
int atoi(const char *str)
{
   string s(str);
   int len = s.length(),flag = 1;
   long res = 0L;
   int index = s.find_first_not_of(' ');
   if(s[index] == '+' || s[index] == '-')
      flag = s[index++]=='-' ? -1 : 1;
   for(;index<len;index++)
   {
       if(s[index] >='0' && s[index] <= '9')
         {
             res = res*10 + (s[index]-'0');
             if(res *flag >= INT_MAX)  return INT_MAX;
             if(res *flag <= INT_MIN) return INT_MIN;
         }
        else
            break;
   }
   return res*flag;
}
};

// 这道题调的好辛苦。。。。。
public class Solution {
    public int atoi(String str) {
        if(str == null || str.trim().length() == 0)
			return 0;
		str = str.trim();
		String res = "";
		int inx = 0;
		String minus = "";

		if(str.charAt(0) == '-'){
			minus = "-";
			inx++;
		}else if(str.charAt(0) == '+'){
			minus = "+";
			inx++;
		}			

		for(int i = inx; i < str.length(); i++){
			if(str.charAt(i) >= '0' && str.charAt(i) <= '9'){
				res += str.charAt(i);
			}else
				break;
		}
		
		if(res == "")
			return 0;
		
		if(Long.valueOf(minus + res) > Integer.MAX_VALUE )	
			return Integer.MAX_VALUE;
		if(Long.valueOf(minus + res) < Integer.MIN_VALUE)	
			return Integer.MIN_VALUE;
		
		return Integer.valueOf(minus + res);   
    }
}

class Solution {
public:
    int atoi(const char *str) {         int num = 0, sign = 1, i = 0;
        int l = strlen(str);
        
        while(str[i]==' ' && i<l)
            i++;
        if(str[i]=='-')
        {
            sign = -1;
            i++;         }else if(str[i]=='+')             i++;                  for(;i<l;i++)         {             if(str[i]<'0' || str[i]>'9')                 break;             if(num>INT_MAX/10 || (num==INT_MAX/10 && (str[i]-'0')>INT_MAX%10))                 return (sign==-1)?INT_MIN:INT_MAX;             num = 10*num + (str[i]-'0');                          }         return sign*num;
    }
};

class Solution {
public:
 int atoi(const char *str) {
  long long res = 0;
  if (NULL == str)
  {
   return res;
  }
  int len = strlen(str);
  bool neg = true;
  int i = 0;
  while (str[i]==' '||str[i]=='0')
  {
   i++;
  }
  if (str[i]=='-')
  {
   neg = false;
   i++;
  }
  else if(str[i]=='+')
  {
   i++;
  }
  for (; i < len; i++)
  {
   char ch = str[i];
   if (ch >= '0'&&ch <= '9')
   {
    res = res * 10 + ch - '0';
    if (res>INT_MAX)
     return neg ? INT_MAX : INT_MIN;
   }
   else
   {
    return  neg ? res : (-1)*res;
   }
  }
  return neg ? res : (-1)*res;
 }
};

class Solution:
    def atoi(self , s ):
        # write code here
        t = []
        flag = 1
        s = s.strip()
        for i in range(len(s)):
            if "0" <= s[i] <= "9":
                t.append(s[i])
            elif i==0 and s[i]=="-":
                flag = -1
            elif i == 0 and s[i]=="+":
                flag = 1
            else:
                break
        if t:
            return flag*(int("".join(t)))
        else:
            return 0

    public int atoi (String s) {
        if (s == null) {
            return 0;
        }
        s = s.trim();
        if (s.length() == 0) return 0;
        int sign = 1;
        int index = 0;
        if (s.charAt(0) == '+' || s.charAt(0) == '-') {
            sign = s.charAt(0) == '+' ? 1 : -1;
            index = 1;
        }
        int res = 0;
        while (index < s.length()) {
            char c = s.charAt(index);
            if (c - '0' < 0 || c - '0' > 9) {
                break;
            }
            int tempRes = res * 10 + (c - '0');
            if (tempRes / 10 != res) {
                return sign > 0 ? Integer.MAX_VALUE : Integer.MIN_VALUE;
            }
            res = tempRes;
            index++;
        }
        return res * sign;
    }

实际上这个题目测试用例还是不完善。少了e这个字样。因此只需要判断空串、符号、溢出即可。

import java.util.*;
public class Solution {
    public int atoi (String str) {
         int i=0;
         int flag=0;
        if(str.isEmpty())return 0;
        while(true){
            if(str.charAt(i)=='+'||str.charAt(i)=='-')
            {    
                 if(str.charAt(i)=='-')
                     flag=1;
                 i++;
                 break;
            }  
            else if(str.charAt(i)='0'){
                break;
            }
            else i++;
        }
        int start = i;
        if(i<str.length()){
            int highbit = str.charAt(i)-'0';
            i++;
            for(;i<str.length();++i){
               // sum =sum*10+str.charAt(i)-'0';
                 if(!(str.charAt(i)='0'))break;
                if(i-start>=10){
                    if(flag ==1)
                        return -2147483648;
                    return 2147483647;
                }
                highbit = highbit*10+str.charAt(i)-'0';
            }
            return flag==1?-highbit:highbit;
        }
        return 0;
    }
}