力扣LeetCode算法题第9题-回文数

要求：

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

 我最初的设计思路是：

1.外循环用来遍历所有的数
2.内循环则让左右指针用来移动对比。

public static boolean isPalindrome1(int x) {
        //给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。
        //回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
        //例如，121 是回文，而 123 不是。
        //思路：用最简单的办法是：用两个循环。
        //1.外循环用来遍历所有的数
        //2.内循环则让左右指针用来移动对比。
        String s = String.valueOf(x);

        // 测试:  s="12345467";
        boolean result=false;
        if(s.length()>2){
            for (int i = 0; i < s.length()/2; i++) {
                // s=121    s=1221    s=12321
                for (int j = s.length(); j > s.length()/2; j--) {
                    System.out.println("a="+s.charAt(i));
                    System.out.println("b="+s.charAt(j));
                    if(s.charAt(i) == s.charAt(j)){
                        result=true;
                    }else {
                        return false;
                    }
                }
            }
        }else if(s.length()==2){
            if(s.charAt(0)==s.charAt(1)){
                return true;
            }
        }else if(s.length()==1){
            return true;
        }

        return result;
    }

但这个算法还是有缺陷。有待完善。

后面想出了第二种办法：字面意思。

把这个数进行反转，如果还是相等，那么就是回文.

public static boolean isPalindrome2(int x) {
        if(x<0)
            return false;
        //最简单明了的办法

        //转字符串，进行反转。
        String s = String.valueOf(x);
        StringBuilder stringBuilder =new StringBuilder(s);
        String s_reverse = stringBuilder.reverse().toString();
        int y = Integer.parseInt(s_reverse);
        //int y = Integer.parseUnsignedInt(s_reverse,1000000000);

        return y==x;
    }

这个方法只是提供思路，转字符串后，无法正常解析回Int类型。数值超过1亿会无法解析。

第三种方法是模拟第二种方法的思路，也是反转。

public static boolean isPalindrome(int x) {
        if(x<0)
            return false;
        int rem=0,y=0;
        int quo=x;
        while(quo!=0){
            rem=quo%10;//第一步
            y=y*10+rem;//第二步
            quo=quo/10;//第三步
        }
        return y==x;
    }

这个算法通过了，所有的测试用例。

算法讲解：

整个循环的作用就是把x的数进行倒置。

例如：12322

对12322进行取余

第一次取余=2，除以10后x=1232

第二次取余=2，再除以10后x=123

第三次取余=3.除以10后x=12

第四次取余=4.除以10后x=1

第三次取余=5.除以10后x<0

得到倒置的y值=22321。不等于x值，所以不是回文。

贴上所有的代码：

package com.zhm.test;

import java.util.Arrays;

/**
 * @Author bige
 * @Date: 2022/11/20 21:56
 * @ApiNote:回文数
 */
public class Leatcode_test009 {

    public static boolean isPalindrome1(int x) {
        //给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。
        //回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
        //例如，121 是回文，而 123 不是。
        //思路：用最简单的办法是：用两个循环。
        //1.外循环用来遍历所有的数
        //2.内循环则让左右指针用来移动对比。
        String s = String.valueOf(x);

        // 测试:  s="12345467";
        boolean result=false;
        if(s.length()>2){
            for (int i = 0; i < s.length()/2; i++) {
                // s=121    s=1221    s=12321
                for (int j = s.length(); j > s.length()/2; j--) {
                    System.out.println("a="+s.charAt(i));
                    System.out.println("b="+s.charAt(j));
                    if(s.charAt(i) == s.charAt(j)){
                        result=true;
                    }else {
                        return false;
                    }
                }
            }
        }else if(s.length()==2){
            if(s.charAt(0)==s.charAt(1)){
                return true;
            }
        }else if(s.length()==1){
            return true;
        }

        return result;
    }

    public static boolean isPalindrome(int x) {
        if(x<0)
            return false;
        int rem=0,y=0;
        int quo=x;
        while(quo!=0){
            rem=quo%10;
            y=y*10+rem;
            quo=quo/10;
        }
        return y==x;
    }

    public static boolean isPalindrome2(int x) {
        if(x<0)
            return false;
        //最简单明了的办法

        //转字符串，进行反转。
        String s = String.valueOf(x);
        StringBuilder stringBuilder =new StringBuilder(s);
        String s_reverse = stringBuilder.reverse().toString();
        int y = Integer.parseInt(s_reverse);
        //int y = Integer.parseUnsignedInt(s_reverse,1000000000);

        return y==x;
    }

    public static void main(String[] args) {
        //int x =123454321;
        //int x =121;
        //int x =-121;
        //int x =0;
        //int x =11;
        int x = 1000021;
        //int x = 1001;
        System.out.println("num="+x+",result="+isPalindrome2(x));
    }
}

给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。

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