题目：

Determine whether an integer is a palindrome. Do this without extra space.

Some hints:

Could negative integers be palindromes?

(ie, -1)

If you are thinking of converting the integer to string, note the restriction of using extra space.

You could also try reversing an integer. However, if you have solved the problem "Reverse Integer", you know that the reversed integer might overflow. How would you handle such case?

There is a more generic way of solving this problem.

题意：

推断一个整数是否为回文数。

不要利用额外的空间。

一些提示：负数不是回文数。假设考虑将整数转化为字符串，注意空间的限制；假设尝试转置这个整数。要注意溢出的问题。

算法分析：

这里利用题目《

Reverse Integer

AC代码：

public class Solution 
{
	private  int i;
	private  int labelnum;
	private  long finalnum;
	private  int finalnnum;
	private  int checkresult;
	private  int label;
    private int y;
    private boolean blabel;
    public boolean isPalindrome(int x) 
    {
          y=reverse(x);//将原整数进行转置
          if (y==0)
          {
        	  if(x==y) blabel=true;//转制前后都是0
        	  else blabel=false;//原整数不是0，转置后变为0，表明出现溢出
          }
          else if(x<0)//负数不是回文数
            blabel=false;
          else if(x==y)
            blabel=true;
          else 
            blabel=false;
          return blabel;
    }
    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;
    }   
}

public class Solution {
    public boolean isPalindrome(int x) {
        if(x<0) return false;//负数不是回文
        if(x==0) return true;
        //对数值进行翻转，回文翻转之后还等于原来的数
        int reverseNum=0;
        int num=x;
        while(num>0)
        {
            int modnum=num%10;
            //考虑翻转会溢出的情况
            if((reverseNum>Integer.MAX_VALUE/10)||((reverseNum==Integer.MAX_VALUE/10)&&(modnum>Integer.MAX_VALUE%10)))
                return false;
            reverseNum=reverseNum*10+modnum;
            num=num/10;
        }
        if(reverseNum==x)
            return true;
        else
            return false;
    }
}