精华内容
下载资源
问答
  • java回文数判断

    千次阅读 2019-07-30 16:08:19
    java简单算法实现回文数判断

    题目详情:
    判断一个整数是否是回文数。回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数

    java类:

    package com.example.study02;
    
    public class IsPalindrome {
        public boolean isPalindrome(int x) {
        	// 特殊情况:
            // 如上所述,当 x < 0 时,x 不是回文数。
            // 同样地,如果数字的最后一位是 0,为了使该数字为回文,
            // 则其第一位数字也应该是 0
            // 只有 0 满足这一属性
        	if(x<0||(x%10==0&&x!=0)){
        		return false;
        	}
        	int num=0;
        	//这个判断很巧妙,X是正向值,num是反向值
        	while(x>num){
        		num=num*10+x%10;
        		x/=10;
        	}
        	
            // 当数字长度为奇数时,我们可以通过 num/10 去除处于中位的数字
            // 例如,当输入为 12321 时,在 while 循环的末尾我们可以得到 x = 12,num = 123,
            // 由于处于中位的数字不影响回文(它总是与自己相等),所以我们可以简单地将其去除
        	return x==num||x==num/10;
        }
    }
    
    

    测试类:

    package com.example.study02;
    
    import static org.junit.Assert.*;
    
    import org.junit.Test;
    
    public class IsPalindromeTest {
    
    	@Test
    	public void test() {
    		IsPalindrome i=new IsPalindrome();
    		System.out.println(i.isPalindrome(1234321));
    		System.out.println(i.isPalindrome(123123));
    	}
    
    }
    
    

    运行结果:
    在这里插入图片描述
    关注公众号,获取更多资源
    在这里插入图片描述

    每天进步一点点,开心也多一点点

    展开全文
  • *** 判断一个整数是否是回文数回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。** * 示例 1: 输入: 121 输出: true 示例 2: 输入: -121 输出: false 解释: 从左向右读, 为 -121 。 从右向左读, ...

    /**
    *** 判断一个整数是否是回文数。回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。**
    *

    • 示例 1:
    • 输入: 121
    • 输出: true
    • 示例 2:
    • 输入: -121
    • 输出: false
    • 解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
    • 示例 3:
    • 输入: 10
    • 输出: false
    • 解释: 从右向左读, 为 01 。因此它不是一个回文数。
      */
    public static boolean isPalindrome(int x){
            StringBuilder str=new StringBuilder();
            if(x<0){
                return false;   //负数直接不成立
            }
            else{
                str.append(x);  
                str.reverse();  //倒转字符串
                try {                                          
                    if(x==Integer.parseInt(str.toString())){ 
                        return true;
                    }
                }
                catch (NumberFormatException e){   //int型范围(-2147483648——2147483647)防止转换后溢出发生异常;
                    return false;
                }
            }
            return false;
        }
    

    NumberFormatException:

    数据转换异常 字符串带着字符转整数等 或者 转换后溢出!!!


    ——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
    还可以不转换成字符串只需要翻转一半数值和之前比较就可以!!
    例如 1221 翻转21变成12 和前面一半比较就可以!!!

    若字符个数为奇数则最中间的数无需考虑!
    例如12321 3无需考虑!!

    若为负数直接 return false!!!!!

    翻转后的数值是否大于int能表示的最大数来判断是否发生了异常!!


    算法代码后续添加!

    展开全文
  • 主要介绍了java 实现判断回文数字的实例代码的相关资料,需要的朋友可以参考下
  • java回文数判断方法

    2020-06-06 17:06:01
    判断是否是回文数 import java.util.*; public class Yanjiu2 { public static void main(String [] args){ Scanner sc = new Scanner(System.in); System.out.println("请输入整型:"); int a = sc.nextInt()...

    判断是否是回文数

    import java.util.*;
    public class Yanjiu2 {
        public static void main(String [] args){
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入整型数:");
            int a = sc.nextInt();
            System.out.println("--------------------------------");
            String b = a+"";
            String c = new StringBuffer(b).reverse().toString();//反转;
            System.out.println("倒序前:"+b);
            System.out.println("倒叙后:"+c);
            boolean e = b.equals(c);
            if(e)
                System.out.println(a+"是回文数");
            else
                System.out.println(a+"不是回文数");
        }
    }
    
    展开全文
  • Java回文数判断

    2020-11-22 10:57:28
    Java中回文判断 package com.wyw; import java.util.Stack; /** * 判断是否为回文字符串 * @author Administrator */ public class HuiWen { public static void main(String[] args) { System.out....

    Java中回文数的判断

    1.字符串回文数判断

    package com.wyw;
    
    import java.util.Stack;
    
    /**
     * 判断是否为回文字符串
     * @author Administrator
     */
    public class HuiWen {
        public static void main(String[] args) {
            System.out.println(f1("12321"));
            System.out.println(f2("abcba"));
            System.out.println(f3("Aa           bcb aA "));
        }
    
        /**
         * 通过数组的方式进行判断
         * 1.创建两个大小为字符串长度大小的数组
         * 2.对字符串转变为数组
         * 3.把久数组的值放入新数组中
         * 4.进行两个数组的判断
         * 注意:字符串有length()方法,而数组有length属性。
         * @param target
         * @return
         */
        private static boolean f1(String target) {
            char[] str = new char[target.length()];
            char[] newStr = new char[target.length()];
            target.getChars(0,target.length(),str,0);
            for (int i = 0; i < str.length; i++) {
                newStr[i] = str[str.length - 1 -i];
            }
            for (int i = 0; i < str.length; i++) {
                if (str[i] != newStr[i]) {
                    return false;
                }
            }
            return true;
        }
    
        /**
         * 通过栈的方式进行回文数判断
         * 1.首先创建一个栈
         * 2.对栈进行入栈,然后出栈
         * 3.进行判断
         * @param target
         * @return
         */
        public static boolean f2(String target) {
            Stack<Character> stack = new Stack<>();
            for (int i = 0; i < target.length(); i++) {
                stack.push(target.charAt(i));
                //System.out.println(target.charAt(i));
            }
            for (int i = 0; i < target.length(); i++) {
                Character character = stack.pop();
                if (character != target.charAt(i)) {
                    return false;
                }
            }
            return true;
        }
    
        /**
         * 通过指针的方式进行回文数判断
         * 1.首先去除输入字符串的空格,以及使所有的字符变成小写
         * 2.创建两个指针,一个头指针,一个尾指针
         * 3.进行判断
         * @param target
         * @return
         */
    
        public static boolean f3(String target) {
            String newTarget = target.replaceAll(" ","").toLowerCase();
            System.out.println(newTarget);
            int preIndex = -1;
            int lastIndex = newTarget.length();
            for (int i = 0; i < newTarget.length()/2; i++) {
                preIndex++;
                lastIndex--;
                if (newTarget.charAt(preIndex) != newTarget.charAt(lastIndex)) {
                    return false;
                }
            }
            return true;
        }
    }
    
    

    2.链表回文数判断

    package com.wyw;
    
    import javax.print.attribute.standard.NumberUp;
    import java.util.Stack;
    
    /**
     * 判断是否为回文
     * @author Administrator
     */
    public class LinkedHuiWen {
        public static void main(String[] args) {
           Node head = new Node('a');
           Node b1 = new Node('b');
           Node b2 = new Node('a');
           Node b3 = new Node('b');
           Node b4 = new Node('a');
    
           head.next = b1;
           b1.next = b2;
           b2.next = b3;
           b3.next = b4;
    
           System.out.println(f2(head));
        }
    
        /**
         * 1.首先使用栈进行入栈
         * 2.进行出栈,并做比较
         * @param head
         * @return
         */
        static boolean f1(Node head) {
            Node ref = head;
            Stack<Character> stack = new Stack<>();
            while (ref != null){
                stack.push(ref.data);
                ref = ref.next;
            }
    
            ref = head;
            while (ref != null) {
                Character pop = stack.pop();
                if (pop != ref.data) {
                    return false;
                }
                ref = ref.next;
            }
            return true;
        }
    
        /**
         * 使用快慢指针来解决这个回文
         * @param head
         * @return
         */
        public static boolean f2(Node head) {
            // 快指针一次走两步
            Node q = head;
            // 慢指针一次走一步
            Node s = head;
            while (q != null && q.next !=null) {
                q = q.next.next;
                s = s.next;
            }
            q = s;
            
            // 链表的原地反转
            Node temp = new Node(s.data);
            temp.next = s.next;
    
            while (temp.next != null) {
                Node pre = s;
                s = temp.next;
                temp.data = s.data;
                temp.next = s.next;
                s.next = pre;
            }
    
            q.next = null;
            q = head;
            while (q.next != null) {
                if (q.data != s.data) {
                    return false;
                }
                q = q.next;
                s = s.next;
            }
            return true;
        }
    
        static class Node {
            public char data;
            public Node next;
    
            public Node(char data) {
                this.data = data;
            }
        }
    }
    
    

    3.双指针(Two Pointers)

    在这里插入图片描述

    3.1 同向指针

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述

    public static int removeDuplicates(int[] nums) {
        // 1 2 2 2 3 4 5
        int i = 0, j = 0;
        while (j < nums.length) {
            if (i == 0 || nums[j] != nums[i - 1]) {
                nums[i] = nums[j];
                i++;
                j++;
            } else {
                j++;
            }
        }
        return i;
    }
    

    3.2 反向指针

    在这里插入图片描述

    编写一个函数,其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
    不要给另外的数组分配额外的空间,你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。 你可以假设数组中的所有字符都是 ASCII
    码表中的可打印字符。

    示例 1:

    输入:["h","e","l","l","o"]
    输出:["o","l","l","e","h"]
    

    示例 2:

    输入:["H","a","n","n","a","h"]
    输出:["h","a","n","n","a","H"]
    

    在这里插入图片描述
    在这里插入图片描述

      public  static void reverseString(char[] s) {
            int i = 0 , j = s.length - 1;
            while (i < j) {
                char temp = s[i];
                s[i] = s[j];
                s[j] = temp;
                i++;
                j--;
            }
            System.out.println(Arrays.toString(s));
        }
    
    展开全文
  • java实现回文数判断

    万次阅读 2021-03-05 14:20:15
    例如,121 是回文,而 123 不是。 解析 public static boolean isPalindrome(int x) { int temp = x; //a取值整数的末位 int a = temp % 10; while (true) { //小于10,直接返回 if (temp < 10) { ...
  • 回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数 目录方法一方法二 方法一 通过==String.valueOf()方法把整数转换为字符串,再用toCharArray()==方法将字符串转化为字符数组,通过数组的第一个和最后...
  • java实现回文数字判断

    千次阅读 2019-06-19 09:08:04
    思路:先将整型数字转换为String包装类型,然后将String转换为char数组,最后根据前后指针i和j比较所指的数字。 public static boolean isHuiWen(int x) { String str = String.valueOf(x); char[] array2 = str...
  • Java回文数

    2020-10-26 23:29:08
    标题Java回文数 回文介绍: 设n是一任意自然数。若将n的各位数字反向排列所得自然数n1与n相等,则称n为一回文。例如,若n=1234321,则称n为一回文;但若n=1234567,则n不是回文。 1.偶数个的数字也有回文...
  • Java判断一个是否是回文数

    千次阅读 2019-08-31 08:52:48
    题目解析: 回文是指正序(从左到右),倒序(从右到左)读都是一样的整数 举例说明: 121、11211是回文数 -123、123不是回文数 ... //进行判断是不是回文数 if(n<0) { return false; } int num = n; ...
  • * 判断一个数字是否是回文数字(即正着读和反着读都一样):譬如输入1331 打印:这是回文数字 1332就不是 * 要点提取:关键在于如何将字符串拆分成单个字符----charAt()方法 * 思路分析:首先需要将整型的数据转化...
  • java判断回文数字Here you will learn about number palindrome in java. 在这里,您将了解Java中的数字回文。 A number is called palindrome if it is equal to its reverse. 如果数字等于回文,则称为回文。...
  • 编写一个Java应用程序。用户从键盘输入一个1~99999之间的,程序将判断这个是几位,并判断这个是否是回文数回文数是指将该含有的数字逆序排列后得到的和原相同,如12121和3223都是回文
  • 使用java语言实现回文判断,当你输入一个数字的时候判断是否为回文
  • 主要介绍了java判断回文数示例,需要的朋友可以参考下
  • Java实现回文数判断

    2021-04-01 16:55:53
    回文数 一种数字,如12321;...然后用a每一次乘10接收,最后产生与i相反的,如相等,就判断为回文。 public class Main { public static void main(String[] args) { for (int i=1000;i<10000;i++){
  • 使用java编写的小程序,能够判断是几位,并输出。以及判断是否是回文数,希望能够帮助大家。
  • Java判断回文数 1、什么是回文数呢? 就是这样的数字12321、11111、63936这样正着读和反着读都是一样的数字就叫做回文。 2、要明白两种运算 :/和% /:相除运算,在这里要注意的是两个整数之间相处的话得到的...
  • Java判断回文数字与素数判断素数判断回文数字完整代码 判断素数 素数又称质数。所谓素数是指除了 1 和它本身以外,不能被任何整数整除的,例如17就是素数,因为它不能被 2~16 的任一整数整除。 思路1):因此判断一...
  • java 判断回文数详解

    2020-04-13 15:33:38
    1,如果是一个数字类型,比如int类型,我们可以这样判断 1 private static boolean palindromic1(int num) { 2 List<Integer> bit = new ArrayList<>(); 3 while (num != 0)...
  • 1.利用StringBuilder 的reverse()反转字符串方法,实现判断回文数 //回文数:是一种数字。如:98789, 这个数字正读是98789,倒读也是98789 //正读倒读一样,所以这个数字就是回文 import java.util....
  • Java算法:回文数

    千次阅读 2019-09-08 17:09:58
    一个正整数,如果交换高低位以后和原相等,那么称这个回文数。比如 121121,23322332都是回文,13,456713,4567 不是回文。 任意一个正整数,如果其不是回文,将该交换高低位以后和原相加得到一个新...
  • <1> import java.util.*; public class Yancey17{ public static void main... //练习回文数 Scanner input=new Scanner(System.in); System.out.println("输入一个"); int num=input.nextInt...
  • 可以发现中间的就一直在中间,回文数判断只需要判断第一位与后一位 ,第二位与倒数第二位相对就行了 public static void main(String[] args) { int a=0,b=0,c=0,d=0; int f=10000; while(f<100000){ a=f/...
  • java 回文数(1-9999)

    2009-10-26 20:21:56
    编写一个java应用程序。用户从键盘输入一个1-9999之间的,程序将判断这个是几位,并判断这个是否回文回文数是指将含有的数字逆序排列后得到的和原相同,例如12121,4224,6778776等都是回文
  • java判断回文

    千次阅读 多人点赞 2019-06-22 15:12:39
    //任何一个除以10的余数就是该最后一位 //任何一个除以10的商就是排除掉最后一位后的 //所以 ,一个1234 就可以通过这种方法得到 123 和 4 //接下来对 123 进行同样的操作,就得到 12 和 3 //接下来得到 1...
  • Java判断回文(两种方式)

    千次阅读 2020-02-25 23:37:56
    Java判断回文(两种方式) 回文是一个非常特殊的,它从左边读和从右边读是一样的。例如12321 判断方式有两种。 方式一:对该数字进行分解,然后一一比对,拆解成 1 2 3 2 1,然后第一位跟最后一位比对,第二位跟...
  • 主要介绍了用while判断输入的数字是否回文数的简单实现,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,634
精华内容 5,053
关键字:

java回文数判断

java 订阅