力扣LeetCode算法题 第7题-整数反转

题目要求：

/**
 * 7. 整数反转
 *
 * 给你一个 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
 *
 */

写上解题思路，是先把整数转换成字符串，因为我们知道，字符串中是有一个反转功能的。可以直接进行反转。

public static int reverse(int x) {
        //首先思路是有一个字符串是可以进行反转的
        String binaryStr = String.valueOf(x);

        //System.out.println(binaryStr);
        //1.如果小于0,则flag变成-1
        int flag=1;
        String substring =binaryStr;
        if(x<0){
            //截取掉第一位
            substring= binaryStr.substring(1);
            flag=-1;
            //System.out.println(substring);
        }
        //字母反转
        StringBuilder sb = new StringBuilder(substring);
        sb.reverse();
        try {
            //解析
            String reversedBinaryStr = sb.toString();
            //System.out.println(reversedBinaryStr);
            //System.out.println(Integer.parseInt(reversedBinaryStr)*(flag));
            return Integer.parseInt(reversedBinaryStr)*(-1);
        }catch (Exception e){
            return 0;
        }

    }

代码里有详细的步骤。

那么我这里再提供第二种办法，这种就稍微难以理解一些。也已经添加了注释

    public static int reverse1(int x) { // 定义一个名为reverse的方法，参数为一个整数x
        long flag = 0; // 定义一个长整型变量flag，初始值为0
        while(x != 0) { // 当x不等于0时，执行循环体内的语句
            flag = flag*10 + x%10; // 将flag乘以10再加上x除以10的余数，得到反转后的数
            x = x/10; // 将x除以10，去掉最后一位
        }
        return (int)flag==flag? (int)flag:0; // 如果反转后的数在int类型的范围内，则返回该数，否则返回0
    }

比如：

1.当x等于123，flag=0，进入循环

2.第一次循环，取余%10后，flag=-3.，x=-12

3.第二次循环，取余%10后，flag=-32.，x=-1

3.第三次循环，取余%10后，flag=-321.，x=0

4.跳出循环，输出结果

附上全部的代码，可以自己进行测试：

package com.zhm.test;

/**
 * @params Leetcode_test007
 * @return Leetcode_test007
 * @Author bigeZhong
 * 7. 整数反转
 *
 * 给你一个 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
 *
 */
public class Leetcode_test007 {
    public static int reverse(int x) {
        //首先思路是有一个字符串是可以进行反转的
        String binaryStr = String.valueOf(x);

        //System.out.println(binaryStr);
        //1.如果小于0,则flag变成-1
        int flag=1;
        String substring =binaryStr;
        if(x<0){
            //截取掉第一位
            substring= binaryStr.substring(1);
            flag=-1;
            //System.out.println(substring);
        }
        //字母反转
        StringBuilder sb = new StringBuilder(substring);
        sb.reverse();
        try {
            //解析
            String reversedBinaryStr = sb.toString();
            //System.out.println(reversedBinaryStr);
            //System.out.println(Integer.parseInt(reversedBinaryStr)*(flag));
            return Integer.parseInt(reversedBinaryStr)*(-1);
        }catch (Exception e){
            return 0;
        }

    }

    public static int reverse1(int x) { // 定义一个名为reverse的方法，参数为一个整数x
        long flag = 0; // 定义一个长整型变量flag，初始值为0
        while(x != 0) { // 当x不等于0时，执行循环体内的语句
            flag = flag*10 + x%10; // 将flag乘以10再加上x除以10的余数，得到反转后的数
            x = x/10; // 将x除以10，去掉最后一位
        }
        return (int)flag==flag? (int)flag:0; // 如果反转后的数在int类型的范围内，则返回该数，否则返回0
    }



    public static void main(String[] args) {
        int test1=123;
        int test2=-123;
        int test3=120;
        int test4=0;

//        reverse(test1);
//        System.out.println("==================");
//        reverse(test2);
//        System.out.println("==================");
//        reverse(test3);
//        System.out.println("==================");
//        reverse(test4);

        //reverse1(test1);
        //System.out.println("==================");
        reverse1(test2);
        //System.out.println("==================");
        //reverse1(test3);
        //System.out.println("==================");
        reverse1(test4);


    }

}