给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

示例 1:

输入: 123
输出: 321

示例 2:

输入: -123
输出: -321

示例 3:
输入: 120
输出: 21

注意:
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

转换为String 再反转

Java实现

  1. public int reverse(int x) {
  2.       String a = Integer.toString(x);
  3.       int b = 1;
  4.       if(a.charAt(0) == '-') {
  5.           a = a.substring(1);
  6.           b = -1;
  7.       }
  8.       char[] chars = a.toCharArray();
  9.       char[] chars1 = new char[chars.length];
  10.       for (int i = chars.length - 1; i >= 0; i--) {
  11.           chars1[chars.length - 1 - i] = chars[i];
  12.       }
  13.       Long aLong = Long.valueOf(new String(chars1));
  14.       if(aLong > Integer.MAX_VALUE || aLong < Integer.MIN_VALUE) {
  15.           return 0;
  16.       }
  17.       return (int) (aLong * b);
  19.   }

利用溢出

依次取出当前数字的最后一位数，累加。
关键在于如何判断整数溢出：将每次操作后的数字用临时变量存储，对该变量“反操作”，若与操作前的结果不等，则发生溢出，直接返回0
Java实现 1

  1. class Solution {
  2.     public int reverse(int x) {
  3.         int res = 0 ;
  4.         while(x != 0){
  5.             int temp = x % 10 + res * 10;
  6.             if((temp - x % 10) / 10 != res){ //最关键的一步
  7.                 return 0 ;
  8.             }
  9.             res = temp ;
  10.             x /= 10 ;
  11.         }
  12.         return res ;
  13.     }
  14. }

Java实现 2

  1. class Solution {
  2.     public int reverse(int x) {
  3.         long n = 0;
  4.         while(x != 0) {
  5.             n = n*10 + x%10;
  6.             x = x/10;
  7.         }
  8.         return (int)n==n? (int)n:0;    //利用(int)来溢出判断
  9.     }
  10. }