对简单题重拳出击~！！！
    难度分类:简单中等困难( )
    1.两数之和 *
    题目描述：
    给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
    你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
    解析：因为假设一种输入一个答案，直接两层循环暴力解决

    1. public int[] twoSum(int[] nums, int target) {
    2.          int a[]=new int[2]; //返回的结果
    3.         for (int i = 0; i < nums.length; i++) {
    4.             for (int j = i+1; j <nums.length ; j++) {
    5.                   if((nums[i]+nums[j])==target){
    6.                       a[0]=i;
    7.                       a[1]=j;
    8.                   }
    9.             }
    10.         }
    11.        return a;
    12.     }

    7.整数反转
    题目描述：
    给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
    如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。

    假设环境不允许存储 64 位整数（有符号或无符号）。

    1. public int reverse(int x) {
    2.         int rev = 0;
    3.         while (x != 0) {
    4.             if (rev < Integer.MIN_VALUE / 10 || rev > Integer.MAX_VALUE / 10) {
    5.                 return 0;
    6.             }
    7.             int digit = x % 10;
    8.             x /= 10;
    9.             rev = rev * 10 + digit;
    10.         }
    11.         return rev;
    12.     }

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

    1. public boolean isPalindrome(int x) {
    2.     if(x==0){
    3.           return true;
    4.       }else if(x>0){
    5.           String x1=String.valueOf(x);
    6.           String rev=new StringBuilder(x1).reverse().toString();
    7.           if(Double.valueOf(rev)>Integer.MAX_VALUE){
    8.               return false;
    9.           }
    10.           int x2=Integer.valueOf(rev);
    11.           if(x2==x){
    12.               return true;
    13.           }
    14.       }else {
    15.         return false;
    16.       }
    17.       return false;
    18.     }

    PS:通过编译了，但是效率很差
    官方解题：
    思路
    映入脑海的第一个想法是将数字转换为字符串，并检查字符串是否为回文。但是，这需要额外的非常量空间来创建问题描述中所不允许的字符串。

    第二个想法是将数字本身反转，然后将反转后的数字与原始数字进行比较，如果它们是相同的，那么这个数字就是回文。
    但是，如果反转后的数字大于 \text{int.MAX}int.MAX，我们将遇到整数溢出问题。

    按照第二个想法，为了避免数字反转可能导致的溢出问题，为什么不考虑只反转 \text{int}int 数字的一半？毕竟，如果该数字是回文，其后半部分反转后应该与原始数字的前半部分相同。

    例如，输入 1221，我们可以将数字 “1221” 的后半部分从 “21” 反转为 “12”，并将其与前半部分 “12” 进行比较，因为二者相同，我们得知数字 1221 是回文。

    作者：LeetCode-Solution
    链接：https://leetcode-cn.com/problems/palindrome-number/solution/hui-wen-shu-by-leetcode-solution/
    来源：力扣（LeetCode）

    1. public boolean isPalindrome(int x) {
    2.         // 特殊情况：
    3.         // 如上所述，当 x < 0 时，x 不是回文数。
    4.         // 同样地，如果数字的最后一位是 0，为了使该数字为回文，
    5.         // 则其第一位数字也应该是 0
    6.         // 只有 0 满足这一属性
    7.         if (x < 0 || (x % 10 == 0 && x != 0)) {
    8.             return false;
    9.         }
    11.         int revertedNumber = 0;
    12.         while (x > revertedNumber) {
    13.             revertedNumber = revertedNumber * 10 + x % 10;
    14.             x /= 10;
    15.         }
    17.         // 当数字长度为奇数时，我们可以通过 revertedNumber/10 去除处于中位的数字。
    18.         // 例如，当输入为 12321 时，在 while 循环的末尾我们可以得到 x = 12，revertedNumber = 123，
    19.         // 由于处于中位的数字不影响回文（它总是与自己相等），所以我们可以简单地将其去除。
    20.         return x == revertedNumber || x == revertedNumber / 10;
    21.     }