leetcode-8-字符串转整数 (atoi)(String to Integer)-java

题目及用例

package pid008;
/*字符串转整数（atoi）

实现 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) 。



*/


public class main {
	
	public static void main(String[] args) {
		String [] testTable = {"42","   -42","4193 with words","words and 987","-91283472332","-9223372036854775809"};
		for (String ito : testTable) {
			test(ito);
		}
	}
		 
	private static void test(String ito) {
		Solution solution = new Solution();
		int rtn;
		long begin = System.currentTimeMillis();
		System.out.print(ito);		    
		System.out.println();
		//开始时打印数组
		
		rtn= solution.myAtoi(ito);//执行程序
		long end = System.currentTimeMillis();	
		
		System.out.println(":rtn" );
		System.out.print(rtn);
		System.out.println();
		System.out.println("耗时：" + (end - begin) + "ms");
		System.out.println("-------------------");
	}

}

解法1（成功，38ms，较快）
思路是从头开始找到第一个非空字符串的数，分为正负，数字，非以上情形，再确定第一个数字
再从第一个数字，找到连续的最后一个数字
在用正负加上这串数字，用biginteger与interger的maxvalue与minvalue比较，从而得到最后答案
关键是最后得到的数字可能比long还大，必须得用biginteger来比较

package pid008;

import java.math.BigInteger;
import java.util.Arrays;

public class Solution {
public int myAtoi(String str) {
        
	int length=str.length();
	if(length==0){
		return 0;
	}
	Boolean isPositive=true;
	int begin=-1;
	int end=0;
	
	for(int i=0;i<length;i++){//找到第一个非空
		char now=str.charAt(i);
		if(now!=' '){
			if(now=='+'||now=='-'){//为+-号情况
				
				if(now=='+'){
					isPositive=true;
				}
				else{
					isPositive=false;
				}
				if(i==length-1){//正负号为最后一位
					return 0;
				}
				if(str.charAt(i+1)<='9'&&str.charAt(i+1)>='0'){//下一位是数字
					begin=i+1;
					break;
				}
				else{
					return 0;
				}
				
			}
			else{
				if(now<='9'&&now>='0'){
					begin=i;
					break;
				}
				else{
					return 0;//第一个即不是正负，也不是数字
				}
			}
		}
	}
	
	if(begin==-1){//防止全为空的情况
		return 0;
	}
	
	for(int i=begin;i<length;i++){//得到数字的最后一位
		char now=str.charAt(i);
		if(now<='9'&&now>='0'){
			end=i;
		}
		else{
			break;
		}
	}
	
	String result;
	if(isPositive==true){
		result="+"+str.substring(begin,end+1);
	}
	else{
		result="-"+str.substring(begin,end+1);
	}
	
	BigInteger resultlong=new BigInteger(result);
	if(resultlong.compareTo(new BigInteger(String.valueOf(Integer.MAX_VALUE)))==1){
		return Integer.MAX_VALUE;
	}
	if(resultlong.compareTo(new BigInteger(String.valueOf(Integer.MIN_VALUE)))==-1){
		return Integer.MIN_VALUE;
	}
	
	
	return (int)Integer.valueOf(result);
    }
	

}

其他的算法，也可以最后不用biginteger，如果长度>10，根据正负号返回，否则用long转化
方法2（成功，7ms，极快）
先跳过空格，然后检测加好减号，得到isPositive为-1或1，以后得到的新的数都要乘以它，
然后逐个遍历数字，每次num*10+nowNum,检验大小是否超出用num>maxValue_10||(num==maxValue_10&&nowNum>7 的方法搞定，maxValue_10为int的maxvalue/10，如果是负的就检验min的

	public int myAtoi(String str) {
		int length=str.length();
		int index=0;
		//先找到第一个非空的index
		while(index<length){
			if(str.charAt(index)==' '){
				index++;
			}
			else{
				break;
			}
		}
		if(index==length){
			return 0;
		}
		char now=str.charAt(index);
		int num=0;
		//num要乘以isPositive
		int isPositive=1;
		//去掉异常情况
		if(now!='+'&&now!='-'&&(now>'9'||now<'0')){
			return 0;
		}
		if(now=='+'){
			index++;
		}
		if(now=='-'){
			isPositive=-1;
			index++;
		}
		int maxValue_10=Integer.MAX_VALUE/10;
		int minValue_10=Integer.MIN_VALUE/10;
		while(index<length){
			now=str.charAt(index);
			if(now>'9'||now<'0'){
				break;
			}
			int nowNum=now-'0';
			if(num>maxValue_10||(num==maxValue_10&&nowNum>7)){
				num=Integer.MAX_VALUE;
				break;
			}
			if(num<minValue_10||(num==minValue_10&&nowNum>8)){
				num=Integer.MIN_VALUE;
				break;
			}
			num=num*10+nowNum*isPositive;
			index++;
		}        		
		return num;
    }