算法日常练习总结

每日练习 记笔记 有的学习于图解算法 ，可以关注此公众号。

字符串

整数反转

给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。
假设环境不允许存储 64 位整数（有符号或无符号）。

示例 1：

输入：x = 123
输出：321
示例 2：

输入：x = -123
输出：-321
示例 3：

输入：x = 120
输出：21
示例 4：

输入：x = 0
输出：0

提示：

-231 <= x <= 231 - 1

题解

首先我们想一下，怎么去反转一个整数？
用栈？
或者把整数变成字符串，再去反转这个字符串？
这两种方式是可以，但并不好。实际上我们只要能拿到这个整数的末尾数字就可以了。
以12345为例，
先拿到5，
再拿到4，
之后是3，2，1，
我们按这样的顺序就可以反向拼接出一个数字了，也就能达到反转的效果。
怎么拿末尾数字呢？好办，用取模运算就可以了

1、将 12345 % 10 得到 5，之后将 12345 / 10
2、将 1234 % 10 得到 4，再将 1234 / 10
3、将 123 % 10 得到 3，再将 123 / 10
4、将 12 % 10 得到 2，再将 12 / 10
5、将 1 % 10 得到 1，再将 1 / 10 这么看起来，一个循环就搞定了，循环的判断条件是 x>0但这样不对，因为忽略了**负数 循环的判断条件应该是 while(x!=0)，**无论正数还是负数，按照上面不断的/10 这样的操作，最后都会变成 0，所以判断终止条件就是!=0 有了取模和除法操作，对于像 12300 这样的数字，也可以完美的解决掉了。
注意，题目上还有这么一句
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围 为 [−2^31, 2^31 − 1]。
也就是说我们不能用 long 存储最终结果，而且有些数字可能是合法范围内的数 字，但是反转过来就超过范围了。 假设有 1147483649 这个数字，它是小于最大的 32 位整数 2147483647 的，但是将 这个数字反转过来后就变成了 9463847411，这就比最大的 32 位整数还要大了， 这样的数字是没法存到 int 里面的，所以肯定要返回 0(溢出了)。 甚至，我们还需要提前判断

上图中，绿色的是最大 32 位整数 第二排数字中，橘子的是 5，它是大于上面同位置的 4，这就意味着 5 后跟任何 数字，都会比最大 32 为整数都大。 所以，我们到【最大数的 1/10】时，就要开始判断了 如果某个数字大于 214748364 那后面就不用再判断了，肯定溢出了。 如果某个数字等于 214748364 呢，这对应到上图中第三、第四、第五排的数字， 需要要跟最大数的末尾数字比较，如果这个数字比 7 还大，说明溢出了。
对于负数也是一样的

上图中绿色部分是最小的 32 位整数，同样是在【最小数的 1/10】时开始判断 如果某个数字小于 -214748364 说明溢出了 如果某个数字等于 -214748364，还需要跟最小数的末尾比较，即看它是否小于 8 第八题字符串转换整数 (atoi)

 class Solution {
   
        public int reverse(int x) {
   
            int res = 0;
            while (x != 0) {
   
                //每次取末尾数字
                int tmp = x % 10;
                //判断是否 大于 最大 32 位整数
                if (res > 214748364 || (res == 214748364 && tmp > 7)) {
   
                    return 0;
                }
                //判断是否 小于 最小 32 位整数
                if (res < -214748364 || (res == -214748364 && tmp < -8)) {
   
                    return 0;
                }
                res = res * 10 + tmp;
                x /= 10;
            }
            return res;
        }
    }
2. 对于范围取数 long的范围
 //判断这里如果int的n==long的n，显然不会越界，返回n，否则就是0，牛逼
        return (int) n == n ? (int)n : 0;

回文数

给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。
回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。

示例 1：

输入：x = 121
输出：true
示例 2：

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

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

输入：x = -101
输出：false

提示：

-231 <= x <= 231 - 1

题解1

用字符串很好理解，但这样的操作纯属多余，实际上我们只需要拿到原数字的最 后一位就可以了， 我们用取模运算，就能拿到数字的最后一位，然后用 res*10 + x%10 这种方式就可以反向的拼接出来了。

6. 12321 通过 %10 得到 1，再将老数字 12321/10
7. 将 1232%10 得到 2，再将新数字 110 + 2 得到 12，同时老数字 1232/10
8. 将 123%10 得到 3，新数字 1210 + 3 得到 123，同时老数字 123/10
9. 将 12%10 得到 2，新数字 12310 + 2 得到 1232，同时老数字 12/10
10. 将 1%10 得到 1，新数字 123210 + 1 得到 12321，同时老数字 1/10
最后比较原数字 12321 和新拼接出来的数字 12321 这种方式有一个隐藏的细节问题，不知道你注意到了没。 如果我们输入的是最大 32 位整数 2147483647，这个数字本身是没有问题，是一 个合法的 32 位最大整数，用 int 存储也没问题，但是如果将这个数字反转的话， 其大小超过了 32 位最大整数，也就是会溢出
那是否要把变量的类型改成 long 来存储呢，这样反转后的数字就不会溢出了。 其实不用，虽然我们反转的数字不对，但是返回的结果却是对的。 因为 32 位整数中最大的回文数 是 2147447412，这个数字是比最大 32 位整数 小
的。所以超过 2147447412 大小的数字也就不是回文数字了，虽然我们经过反转后的 数字溢出了，但它的返回结果却是对的，这也算是歪打正着。于是我们继续用 int 类型来保存数字，也没问题。

class Solution {
   
                public boolean isPalindrome(int x) {
   
                    if (x < 0) {
   
                        return false;
                    }
                    int ans = 0;
                    int old = x;
                    while (x > 0) {
   
                        ans = ans * 10 + x % 10;
                        x /= 10;
                    }
                    return ans == old;
                }
            }

题解2

用字符串做反转 ：
这种方式很简单，将整数 x 变成字符串，然后再拷贝一份字符串，将拷贝后的字 符串反转一下。 再比较原字符串和拷贝后的字符串就可以了。

当然有些特殊情况需要预先处理一下，当 x<0 时候就没法拼接出一个回文数字， 所以当 x<0 时就直接返回 false。

class Solution {
   
        public boolean isPalindrome(int x) {
   
            if (x < 0) {
   
                return false;
            }
            String oldStr = "" + x;
            String newStr = new StringBuilder("" + x).reverse().toString(