Leetcode 反转整数+回文数 相关知识点

反转整数

题目

给定一个 32 位有符号整数，将整数中的数字进行反转。

示例 1:
输入: 123
输出: 321

示例 2:
输入: -123
输出: -321

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

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

知识点

整形、长整型、浮点型 边界值

  • int型边界最大值：Integer.MAX_VALUE
  • int型边界最小值：Integer.MIN_VALUE
  • long型边界最大值：Long.MAX_VALUE
  • long型边界最小值：Long.MIN_VALUE
  • float型边界最大值：Float.MAX_VALUE
  • float型边界最小值：Float.MIN_VALUE

整形与长整型之间的转换

不要直接将数据类别强制转换，会编译出错。
较好方式有两种（long a = 23;）

  1. 借助Long类：
    int new_a = new Long(a).intValue();
  2. 借助字串：
    int new_a = Integer.parseInt(String.valueOf(y));

解法

其实将整数反转并不难，每次将旧整数的最后一位取余放到新整数的后面即可。当然我们也可以将整数变为字串，用字符两两交换的方法，只是效率会更低。
对于大多数人来说，这道题最容易忽略的地方在于，数值溢出的判定条件。我想到的方式有两种：

  • 解法一：将逆序后的值直接与边界值比较。
public int reverse(int x) {
        long y = 0;
        while(x != 0){
            y = y*10 + x%10;
            x = x/10;
        }
        if(y < Integer.MIN_VALUE || y > Integer.MAX_VALUE){
            return 0;
        }
        else{
            //return new Long(y).intValue();
            return Integer.parseInt(String.valueOf(y));
        }    
    }
  • 解法二：将逆序的整数先用long型表示，看逆序数long型和int型数值是否一致。
public int reverse(int x) {
        long y = 0;
        while(x != 0){
            y = y*10 + (x%10);
            x = x/10;
        }
        int y1 = new Long(y).intValue();
        if(y1 != y){
            return 0;
        }
        else{
            return y1;
        }
    }

回文数

题目

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

示例 1:
输入: 121
输出: true

示例 2:
输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。

示例 3:
输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数。

进阶:
你能不将整数转为字符串来解决这个问题吗？

知识点

缺省数据类型&对应类

原始类型

封装类

boolean

Boolean

char

Character

byte

Byte

short

Short

int

Integer

long

Long

float

Float

double

Double

Number类常用方法

  • xxxValue()：将Number对象转化为xxx数据类型的值并返回
    – byteValue()：以byte形式返回指定的数值
    – doubleValue()：以double形式返回指定的数值
    – floatValue()：以float形式返回指定的数值
    – intValue()：以int形式返回指定的数值
    – longValue()：以long形式返回指定的数值
    – shortValue()：以short形式返回指定的数值
Long a = new Long(13546);
        b = a.intValue();
        
        // Integer i = 1;
        // Integer n = Integer.valueOf(1);
        Integer i = new Integer(1);
        int j = i.floatValue();
  • public int compareTo(NumberSubClass referenceName)：将number对象与参数比较，返回number对象值-参数的差值
int x = 1;        // x是一个整形数
Integer y = new Integer(2);     // y是一个整形类
return y.compareTo(x);      // 返回d为1
  • public boolean equals(Object o)：判断number对象是否与参数
int x = 5;
Integer y = 10;
Integer z = 5;
return y.equal(x);     // 返回false
return z.equal(x);      //返回true
  • valueof()：返回一个Number对象指定的内置数据类型
    – Integer valueOf(int i)：返回一个表示指定int型的Integer实例
    – Integer valueOf(String s)：返回一个表示指定String型的Integer实例
    – Integer valueOf(String s, int radix)：返回一个Integer对象，该对象中保存了用第二个参数提供的基数进行解析是从指定Sting中提取的值
Integer b = Integer.valueOf("444",16);      //使用16进制
  • toString()：返回以一个字符串表示的Number对象值
    – String toString()
    – static String toString(int i)
Integer x = 5;
return x.toString();
return Integer.toString(12);
  • parseInt()：将字符串解析为int类型
    – static int parseInt(String s)
    – static int parseInt(String s, int radix)
int x = Integer.parseInt("9");
double c = Double.parseDouble("5");
int b = Integer.parseInt("444",16);    //基数“444”为16进制

Math类常用方法

  • abs()：返回参数的绝对值
  • ceil()：返回大于等于（>=）给定参数的最小整数
  • floor()：返回小于等于（<=）给定参数的最大整数
  • rint()：返回与参数最接近的整数，返回类型为double。
  • round()：对数字进行四舍五入。算法为Math.floor(x+0.5)，即将原来的数字加上0.5后再向下取整。所以Math.round(11.5)=12，而Math.round(-11.5)=11。
  • min()：返回两个参数中的最小值
  • max()：返回两个参数中的最大值
  • exp()：返回自然数底数e的参数次方
  • log()：返回参数的自然数底数的对数值
  • pow()：返回第一个参数的第二个次方
  • sqrt()：求参数的算术平方根
  • sin()：求指定double类型参数的正弦值
  • cos()：求指定double类型参数的余弦值
  • tan()：求指定double类型参数的正切值
  • toRadians()：将角度转化为弧度
  • toDegrees()：将参数转化为角度
  • random()：返回一个随机数

解法

想要解这道题，首先要理解回文数的意义，抓两个重点：一是对象——整数；二是左一等于右一，左二等于右二依次类推。还有种情况可以直接排除，只要整数为负则一定是非回文数。
方法一：将整数逆序，然后将逆序前后的数字比较是否一致。当然这种情况需要先判断数字书否为负。

class Solution {
    public boolean isPalindrome(int x) {
        if(x < 0)        return false;
        else{
            int y = 0;
            int x1 = x;
            while(x1 != 0){
                y = y*10+x1%10;
                x1 = x1/10;
            }
            if(x == y)      return true;
            else         return false;
        }
    }
}

方法二：先求数字的长度。通过求商求余逐个将最高位与最低位相比较，相同的话比较次高位和次低位。如果在过程中发现不同，则为非回文数；只有当所有高低位均相同时，才为回文数。

class Solution {
    public boolean isPalindrome(int x) {
        if(x < 0){
            return false;
        }
        else{
            int y = 0;
            int x1 = x;
            while(x1 != 0){
                y = y*10+x1%10;
                x1 = x1/10;
            }
            if(x == y){
                return true;
            }
            else{
                return false;
            }
        }
    }
}

方法三：是方法二的变种，思路是相同的，不同之处在于，法三直接将数字转换为字符串求解，这样代码相对简单。
注释中讲解了int转String常见的三种方法。

class Solution {
    public boolean isPalindrome(int x) {
        // String s = String.valueOf(x);   //法一:int转String
        // String s = x+"";                //法二:int转String        
        String s = Integer.toString(x);    //法三:int转String
        char[] ch = s.toCharArray();  
        // System.out.println(ch[0]);   //只有将String转换成char[]才能对字串中每个字符进行修改
        // int len = s.length();     //String获取字串长度
        int high = ch.length-1;      //数组获取字串长度
        int low = 0;
        while(low < high){
            if(ch[low] != ch[high]){
                return false;
            }
            low += 1;
            high -= 1;
        }        
        return true;
    }
}