[LeetCode][Java] Reverse Integer

题目：

Reverse digits of an integer.

Example1: x = 123, return 321
Example2: x = -123, return -321

题意：

   题意很好理解，就是翻转一个整数。但是需要注意到溢出的情况，题目中假设的是32位的整数，翻转会有溢出的情况，溢出时直接返回0.

算法分析：

  这里我将整数分为正负两种情况处理，先将整数转化为字符串，之后将字符串翻转，判断字符串是否溢出，若不溢出，将该字符串重新转化为翻转后的整数。

  代码稍长，主要是这里引入了一个判断字符串是否满足转化为整数条件的检验函数，这个函数具有普适性。

代码如下：

public class Solution 
{
	private  int i;
	private  int labelnum;
	private  long finalnum;
	private  int finalnnum;
	private  int checkresult;
	private  int label;

    public  int reverse(int x) 
    {
    	String s1=Integer.toString(x);
    	if(s1.charAt(0)=='-')
    	{
    		String s2="-";
    		String finals2="-";
    		String Judges2="";
    		long num1=0L;
    		for(i=s1.length()-1;i>=1;i--) s2+=s1.charAt(i);
    		for(i=1;i<s2.length();i++)
    		{
    			if(s2.charAt(i)!='0') 
    			{
    				labelnum=i;
    				break;
    			}
    		}
    		for(i=labelnum;i<s2.length();i++) 
    		{
    			finals2+=s2.charAt(i);
    		}
    		label=checkstring(finals2);//检查是否存在溢出问题，label=1表明没有溢出；label=0表明产生溢出
    		if(label==1)
    		{
    			finalnum=Integer.parseInt(finals2);
    		}
    		else
    		{
    			finalnum=0;
    		}
    	}
    	else
    	{
    		String s2="";
    		String finals2="";
    		String Judges2="";
    		long num1=0L;
    		for(i=s1.length()-1;i>=0;i--) s2+=s1.charAt(i);
    		for(i=0;i<s2.length();i++)
    		{
    			if(s2.charAt(i)!='0') 
    			{
    				labelnum=i;
    				break;
    			}
    		}
    		for(i=labelnum;i<s2.length();i++)
    		{
    			finals2+=s2.charAt(i);
    		}	
    		label=checkstring(finals2);//检查是否存在溢出问题，label=1表明没有溢出；label=0表明产生溢出
    		if(label==1)
    		{
    			finalnum=Integer.parseInt(finals2);
    		}
    		else{
    			finalnum=0;
    		}
    		
    	}
    	
		return (int) finalnum;
    }
  
    private  int checkstring(String string) 
    {
        checkresult=1;
    	/* 异常情况1：字符串为null */
        if (string == null) checkresult=0;  
        int length = string.length(), offset = 0;
        /* 异常情况2：字符串长度为0 */
        if (length == 0)  checkresult=0; 
        boolean negative = string.charAt(offset) == '-';
        /* 异常情况3：字符串为'-' */
        if (negative && ++offset == length)  checkresult=0; 
        int result = 0;
    	char[] temp = string.toCharArray();
        while (offset < length) 
        {
          char digit = temp[offset++];
          if (digit <= '9' && digit >= '0') 
          {
            int currentDigit = digit - '0';
            /*
             * 异常情况4：已经等于Integer.MAX_VALUE / 10，判断要添加的最后一位的情况：
             * 如果是负数的话，最后一位最大是8 如果是正数的话最后一位最大是7
             * Int 范围：四个字节，-2147483648~2147483647
             */
            if (result == Integer.MAX_VALUE / 10) 
            {
	              if ((negative == false && currentDigit > 7)
	                  || (negative && currentDigit > 8)) 
	              {
	            	  checkresult=0; 
	              }
	              /*
	               * 异常情况5：已经大于Integer.MAX_VALUE / 10
	               * 无论最后一位是什么都会超过Integer.MAX_VALUE
	               */
	            } 
	            else if (result > Integer.MAX_VALUE / 10)
	            {
	            	checkresult=0; 
	            }	
             int next = result * 10 + currentDigit;
             result = next;
           }
        }
		return checkresult;
      }   
}

别人家的代码：

/**
 *  该题是将给定的整数进行逆序输出，可以通过对10进行取余而得到其个位，十位，百位等。
    但是需要注意以下问题：
    
    1.对于负数的逆序，只需要对其正数进行翻转，然后添加符号即可。
    2.逆转之后可能会产生比原数更大的数，从而造成整数的溢出。
    
    You can try this : x = -2147483648 as parameter. 此时-x已经溢出
    There has an easy way to solve the problem. Convert x to long, and check if the result >= Integer.MAX_VALUE, otherwise return 0.
*/
public class Solution 
{
    public int reverse(int x) 
    {
        long k = x;
        boolean isNegtive = false;        
        if(k < 0)
        {
            k = 0 - k;
            isNegtive = true;
        }

        long result = 0;
        while(k != 0)
        {
            result *= 10;
            result += k % 10;
            k /= 10;
        }

        if(result > Integer.MAX_VALUE) return 0;
        return isNegtive  ? 0 - ((int)result) : (int)result;
    }
}