leetcode刷题02day——简单题：整数反转

题目：
给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
示例 1:
输入: 123
输出: 321
示例 2:
输入: -123
输出: -321
示例 3:
输入: 120
输出: 21
注意:
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−2^31, 2 ^31 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

如果是平常的练习，可以用以下代码：

  public int reverse(int x) {
        //首先进行对数的判断：
        int temp = 0;    //用一临时变量保存负数的值
        if (x < 0) {//如果是负数，取绝对值
            temp =x;//提前临时保存
            x = Math.abs(x);
        }
        if (x % 10 == 0) {  //后面赘余多个零时去掉0
            while (x % 10 == 0) {
                x = x / 10;
            }
        }
        //利用队列先进先出的特性
        Queue queue = new LinkedList();
        //对队列进行元素的增加
        while (x > 0) {
            int num = x % 10;
            x = x / 10;
            queue.add(num);
        }
        //此处计算反转后的数值
        int sum =0;
        for (Object y:
          queue ) {
              sum =sum*10;
        sum = sum +(int)y;
    
        }
		//对负数的反转结果添加负号
        if(temp<0) sum =(-1)*sum;
        //对数值所在范围的合法性的判断
        if (sum>Integer.MAX_VALUE||sum<Integer.MIN_VALUE)
            sum=0;
return sum;

以上代码可以实现反转的功能，但是比较耗费内存和时间，故将其简化：
省略掉对正负数的判断，以及对队列的应用，直接对每一次的反转结果进行判断并计算，最后返回相应的结果。
简化代码：

 public int reverse(int x) {
       int result = 0;
        while (x != 0) {  //这里的判断条件不对正负进行限制
           int temp = x % 10;
           // 检查是否越界
           //检查是否越过最大值的界限
           if (result> 0x7FFFFFFF / 10 || result == 0x7FFFFFFF / 10 && temp > 0x7FFFFFFF % 10) {
               return 0;
           }
           //检查是否越过最小值的界限
           if (result < 0x80000000 / 10 || result == 0x80000000 / 10 && temp < 0x80000000 % 10) {
               return 0;
           }
           //计算每一次的反转结果
           result= result* 10 + temp;
           x /= 10;
        }
        return result;
    }
    

小总结：
这里最重要的是对反转后结果的取值合法性进行判断，个人觉得对于 [−2^31, 2 ^31 − 1]的判断，在不知道具体数值的情况下，应用Integer的MAX_VALUE和MIN_VALUE的属性比较简单。