leetcode 9.回文数

日常刷题

leetcode 9.回文数

难度指数：✯

题目：

给你一个数 x ，如果 x 是一个回文整数，返回 true ; 否则，返回 false 。回文数是指正序 (从左向右) 和倒序 (从右向左) 读都是一样的整数
例如，121 是回文，而 123 不是
示例 1:
输入: X = 121
输出: true
示例 2
输入:x = -121
输出: false
解释: 从左向右读，为 -121 。 从右向左读，为 121- 。因此它不是一个回文数
示例 3:
输入:X=10
输出: false
解释: 从右向左读，为 01 。因此它不是一个回文数
进阶:你能不将整数转为字符串来解决这个问题吗?

分析：

第一反应使用 转字符串，不考虑线程安全问题，选择StringBuild类，使用reverse方法，和原字符串比较 可行，但效率上差了点

不转字符串类型，使用算术运算符 % 和 /
% 取余运算 如 10 % 3 == 1
/ 除法运算 如 10 / 3 == 3
先排除负数和尾数为0的数（不包括 0） 然后把前一半数和后一半数进行比较，具体如下
一直循环用 x % 10拿到最后一位 ，乘 10 相加 得到反转后的数
原数进行 / 10 进行下一次循环的x值
当 前一半值小于后一半值，跳出循环，进行比较

答题：

转字符串方式：

 public boolean isPalindrome(int num) {
        String str = String.valueOf(num);
        StringBuilder sb = new StringBuilder(str);
        String res = sb.reverse().toString();
        return str.equals(res);
    }

不转字符串方式：

 public boolean isPalindrome(int num) {

        if (num < 0 || (num % 10 == 0 && num != 0)) {
            return false;
        }

        int reverseNum = 0;
        while (num > reverseNum) {
            reverseNum = reverseNum * 10 + num % 10;
            num /= 10;
        }
        return num == reverseNum || num == reverseNum / 10;
    }

拓展：

StringBuilder 类的 reverse方法源码：

public AbstractStringBuilder reverse() {
        boolean hasSurrogates = false;
        int n = count - 1;
        for (int j = (n-1) >> 1; j >= 0; j--) {
            int k = n - j;
            char cj = value[j];
            char ck = value[k];
            value[j] = ck;
            value[k] = cj;
            if (Character.isSurrogate(cj) ||
                Character.isSurrogate(ck)) {
                hasSurrogates = true;
            }
        }
        if (hasSurrogates) {
            reverseAllValidSurrogatePairs();
        }
        return this;
    }

    /** Outlined helper method for reverse() */
    private void reverseAllValidSurrogatePairs() {
        for (int i = 0; i < count - 1; i++) {
            char c2 = value[i];
            if (Character.isLowSurrogate(c2)) {
                char c1 = value[i + 1];
                if (Character.isHighSurrogate(c1)) {
                    value[i++] = c1;
                    value[i] = c2;
                }
            }
        }
    }

本质是字符转换，即：

private String reverse(String str) {
        char[] chars = str.toCharArray();
        int n = chars.length - 1;
        for (int i = 0; i < chars.length / 2; i++) {
            char temp = chars[i];
            chars[i] = chars[n - i];
            chars[n - i] = temp;
        }
        return new String(chars);
    }

复习一下逻辑运算符：

复习下位运算符：

复习下运算优先级：
单目 > 算术 > 位移 > 关系 > 逻辑 > 三目 > 赋值

总结：

基础运算符使用熟练的话，省去转成字符串类型计算，效率会有提升

基础要牢固~~~