精华内容
下载资源
问答
  • import java.util.*; public class HuiWen { public static void main(String[] args)  { Scanner in = new Scanner(System.in); String str = in.nextLine(); StringBuilder sb = new StringBuilder(); sb...
    import java.util.*;
    
    public class HuiWen
    {
    public static void main(String[] args) 
    {
    Scanner in = new Scanner(System.in);
    String str = in.nextLine();
    StringBuilder sb = new StringBuilder();
    sb.append(str);
    char[] chs = sb.toString().toCharArray();
    char[] chs1 = sb.reverse().toString().toCharArray();
    boolean b = true;
    for (int i = 0;i<chs.length ;i++ )
    {
    if (chs[i] != chs1[i])
    {
    b = false;
    }
    }
    System.out.println(b);
    }
    }
    展开全文
  • JAVA算法:回文字符串相关问题详解(回文字符串总结) Q1. 编写一个工具方法判断给定的字符串是否为回文字符串 例如:给定一个字符串“aabbaa”,判断该字符串是否为回文字符串。 算法设计如下: /* * 给定...

    JAVA算法:回文字符串相关问题详解(回文字符串总结)

    Q1. 编写一个工具方法判断给定的字符串是否为回文字符串

     例如:给定一个字符串“aabbaa”,判断该字符串是否为回文字符串。

    算法设计如下:

    	/*
    	 * 给定一个字符串,判断该字符串是否为一个回文字符串
    	 * start表示需要判断的起始位置
    	 * end表示需要判断的结束位置
    	 */
    
    	public static boolean isPalindrome(String input, int start, int end) {
    		while (start < end) {
    			if (input.charAt(start++) != input.charAt(end--))
    				return false;
    		}
    		return true;
    	}

    完整的测试代码如下:

    package com.bean.algorithm.palindromic;
    
    public class PalindromicUtils {
    
    	/*
    	 * 给定一个字符串,判断该字符串是否为一个回文字符串
    	 * start表示需要判断的起始位置
    	 * end表示需要判断的结束位置
    	 */
    
    	public static boolean isPalindrome(String input, int start, int end) {
    		while (start < end) {
    			if (input.charAt(start++) != input.charAt(end--))
    				return false;
    		}
    		return true;
    	}
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		String str="aabbaa ";
    		//String str="fafadabcbafdfdfas";
    		//注意去掉字符串前后的空格
    		str=str.trim();
    		boolean flag=isPalindrome(str,0,str.length()-1);
    		System.out.println("Flag is: "+flag);
    		
    	}
    
    }
    

    程序运行结果;

    Flag is: true


    Q2. 求给定字符串中的最长回文子串

    输入一个字符串,求出其中最长的回文子串。

    子串的含义是:在原串中连续出现的字符串片段。

    在求解这个问题的时候,一定要看清楚问题。不要混淆“子串”和“子序列”的概念。“子串”是指在源字符串中连续出现的字符串片段;而“子序列”是指在源字符串中可以不连续出现的字符串片段。一个连续,一个不连续。


    回文的含义是:子串从左向右看和从右向左看是相同的,例如:abba,yyxyy。 在判断时忽略所有标点符号和空格,且忽略大小写,但是输出应保持原样。
    输入字符串的长度不超过5000,且占据单独一行。 应该输出最长的回文串。如果有多个,输出起始位置最靠左的一个。

    例如给定字符串:fafadabcbafdfdfas

    其最长回文子串为:afdfdfa

    算法设计如下:

    package com.bean.algorithmexec;
    
    import java.io.FileNotFoundException;
    
    public class LongestPalindromeString3 {
    
    	/*
    	 *  
    	 * 输入一个字符串,求出其中最长的回文子串。 
    	 * 子串的含义是:在原串中连续出现的字符串片段。
    	 * 回文的含义是:子串从左向右看和从右向左看是相同的,例如:abba,yyxyy。 在判断时忽略所有标点符号和空格,且忽略大小写,但是输出应保持原样。
    	 * 输入字符串的长度不超过5000,且占据单独一行。 应该输出最长的回文串。如果有多个,输出起始位置最靠左的一个。
    	 *  
    	 */
    
    	/*
    	 * 动态规划算法
    	 * dp(i, j) 表示是否 s(i ... j) 能够形成一个回文字符串
    	 * 当 s(i) 等于 s(j) 并且  s(i+1 ... j-1) 是一个回文字符串时 dp(i, j) 的取值为 true
    	 * 当我们找到一个回文子字符串时,我们检查其是否为最长的回文字符串
    	 */
    	public static String longestPalindrome(String s) {
    		// n表示字符串的长度
    		int n = s.length();
    		String res = null;
    		// 定义一个dp数组
    		boolean[][] dp = new boolean[n][n];
    		// 外层循环控制从最后一个字符向第一个字符渐进
    		for (int i = n - 1; i >= 0; i--) {
    			// 内层循环控制
    			for (int j = i; j < n; j++) {
    				// dp数组元素
    				dp[i][j] = s.charAt(i) == s.charAt(j) && (j - i < 3 || dp[i + 1][j - 1]);
    
    				if (dp[i][j] && (res == null || j - i + 1 > res.length())) {
    					res = s.substring(i, j + 1);
    				}
    			}
    		}
    
    		return res;
    	}
    
    	public static void main(String[] args) throws FileNotFoundException {
    			// 读取输入的字符串
    			String strdemo = "fafadabcbafdfdfas";
    			String ANSWER = longestPalindrome(strdemo);
    			System.out.println(ANSWER);
    	}
    }
    

    程序运行结果:

    afdfdfa

    另外一种算法:

    package com.bean.algorithmexec;
    
    public class LongestPalindromeString4 {
    
    	static void printSubStr(String str, int low, int high) {
    		System.out.println(str.substring(low, high + 1));
    	}
    
    
    	static int longestPalSubstr(String str) {
    		int maxLength = 1; 
    
    		int start = 0;
    		int len = str.length();
    
    		int low, high;
    
    	
    		for (int i = 1; i < len; ++i) {
    			
    			low = i - 1;
    			high = i;
    			while (low >= 0 && high < len && str.charAt(low) == str.charAt(high)) {
    				if (high - low + 1 > maxLength) {
    					start = low;
    					maxLength = high - low + 1;
    				}
    				--low;
    				++high;
    			}
    
    		
    			low = i - 1;
    			high = i + 1;
    			while (low >= 0 && high < len && str.charAt(low) == str.charAt(high)) {
    				if (high - low + 1 > maxLength) {
    					start = low;
    					maxLength = high - low + 1;
    				}
    				--low;
    				++high;
    			}
    		}
    
    		System.out.print("最长回文子串为: ");
    		printSubStr(str, start, start + maxLength - 1);
    
    		return maxLength;
    	}
    
    	
    	public static void main(String[] args) {
    		String str = "fafadabcbafdfdfas";
    
    		System.out.println("长度是: " + longestPalSubstr(str));
    
    	}
    }
    

    程序运行结果为:

    最长回文子串为: afdfdfa
    长度是: 7


    Q3. 对于给定的字符串输出所有可能的回文子串分区

    例如:给定字符串 str = “bcc”

    输出结果为:["b", "c", "c"], ["b", "cc"]

    算法设计:

    package com.bean.algorithm.palindromic;
    
    import java.util.ArrayList;
    import java.util.Deque;
    import java.util.LinkedList;
    
    public class PrintAllPalindrome {
    
    	public static void main(String[] args) {
    		String input = "abbcbba";
    		//String input = "fafadabcbafdfdfas ";
    		
    		System.out.println("对于给定的字符串 " + input + " 的所有可能的回文分区 :");
    
    		allPalPartitions(input);
    	}
    
    	private static void allPalPartitions(String input) {
    		int n = input.length();
    
    		// 用于存放所有回文子串( palindromic partitions)
    		ArrayList<ArrayList<String>> allPart = new ArrayList<>();
    
    		// 用于存放当前回文子串( palindromic partitions)
    		Deque<String> currPart = new LinkedList<String>();
    
    		// 递归调用方法生成所有分区部分
    		allPalPartitonsUtil(allPart, currPart, 0, n, input);
    
    		// 输出所有分区部分字符串
    		for (int i = 0; i < allPart.size(); i++) {
    			for (int j = 0; j < allPart.get(i).size(); j++) {
    				System.out.print(allPart.get(i).get(j) + " ");
    			}
    			System.out.println();
    		}
    
    	}
    
    
    	private static void allPalPartitonsUtil(ArrayList<ArrayList<String>> allPart, Deque<String> currPart, int start,
    			int n, String input) {
    		
    		if (start >= n) {
    			allPart.add(new ArrayList<>(currPart));
    			return;
    		}
    
    		for (int i = start; i < n; i++) {
    
    			// 如果子串  str[start..i] 是回文子串( palindrome)
    			if (isPalindrome(input, start, i)) {
    
    				currPart.addLast(input.substring(start, i + 1));
    
    				allPalPartitonsUtil(allPart, currPart, i + 1, n, input);
    
    				// 从当前分区中删除子串 str[start..i]
    				currPart.removeLast();
    			}
    		}
    	}
    
    	// 判断字符串是否为回文字符串(Palindrome)的工具方法(utility function) 
    	private static boolean isPalindrome(String input, int start, int i) {
    		while (start < i) {
    			if (input.charAt(start++) != input.charAt(i--))
    				return false;
    		}
    		return true;
    	}
    
    }
    

    程序运行结果:

    对于给定的字符串 abbcbba 的所有可能的回文分区 :
    a b b c b b a 
    a b b c bb a 
    a b bcb b a 
    a bb c b b a 
    a bb c bb a 
    a bbcbb a 
    abbcbba 

     

    展开全文
  • java判断回文字符串几种简单的实现

    万次阅读 多人点赞 2017-10-18 00:49:49
    java判断回文字符串几种简单的实现

    11年it研发经验,从一个会计转行为算法工程师,学过C#,c++,java,android,php,go,js,python,CNN神经网络,四千多篇博文,三千多篇原创,只为与你分享,共同成长,一起进步,关注我,给你分享更多干货知识!

    java判断回文字符串几种简单的实现:


    1.将字符串倒置后逐一比较,实现如下:

    public class HuiWenTest {  
    /** 
     * @SERLIN 
     */  
    public static void main(String[] args) {  
        String str = "";  
        System.out.println("请输入一个字符串");  
        Scanner input = new Scanner(System.in);  
        str = input.next();  
      
        StringBuffer sb = new StringBuffer(str);  
        sb.reverse();// 将Str中的字符串倒置  
      
        int count = 0;  
        for (int i = 0; i < str.length(); i++) {  
            if (str.charAt(i) == sb.charAt(i)) {  
                count++;  
            }  
        }  
        if (count == str.length()) {  
              
            System.out.println("此字符串是一个回文字符串");  
        } else {  
            System.out.println("此字符串不是一个回文字符串");  
        }  
    }  


    2.将字符串倒置后创建新字符串直接比较,实现如下:

    public class HuiWenTest2 {  
        /** 
         * @SERLIN 
         */  
        public static void main(String[] args) {  
            System.out.println("请输入一个字符串");  
            Scanner input = new Scanner(System.in);  
            String str = input.next();  
            StringBuilder sb=new StringBuilder(str);  
            sb.reverse();//将str倒置的方法  
            String newStr=new String(sb);  
            if(str.equals(newStr)){  
                System.out.println(str+"是回文字符串");  
            }else{  
                System.out.println(str+"不是回文字符串");  
            }  
        }  
    }  


    3.使用截取字符串的方式比较,实现如下:

    public class HuiWenTest3 {  
        /** 
         * @SERLIN 
         */  
        public static void main(String[] args) {  
            System.out.println("请输入一个字符串");  
            Scanner input = new Scanner(System.in);  
            String str = input.next();  
            int count = 0;  
            for (int i = 0; i < str.length() / 2; i++) {  
            if ((str.substring(i, i + 1)).equals(str.substring(str.length() - 1- i, str.length() - i))) {  
                    count++;  
                }  
            }  
            if (count == str.length() / 2) {  
                System.out.println("是回文字符串");  
            }else{  
                System.out.println("不是回文字符串");  
            }  
        }  
    }  


    4.判断回文数字(判断纯数字),实现如下

    public class HuiWenNum {  
        /** 
         * @SERLIN 
         */  
        public static void main(String[] args) {  
            int n;  
            System.out.println("请输入一个整数:");   
            // 如果结果为回文数,跳出循环  
            while (true) {  
                Scanner InpuNum = new Scanner(System.in);  
                n = InpuNum.nextInt();  
                if (isHuiWen(n)) {  
                    System.out.println(n + "是回文数!");  
                    break;  
                } else {  
                    System.out.println(n + "不是回文数!");  
                }  
            }  
        }  
      
      
        // 判断的数字是否是回文数  
        public static boolean isHuiWen(int n) {  
            int m = reverse(n);  
            if (m == n) {  
                return true;  
            } else {  
                return false;  
            }  
        }  
      
      
        // 将输入的数字进行倒置,以便进行判断是否是回文数  
        public static int reverse(int n) {  
            int temp = 0;// 临时变量  
            int j = 0;// 倒置后的数字  
            temp = n;// 将输入的数字赋值给临时变量  
            while (temp != 0) {  
                j = j * 10 + temp % 10;  
                temp /= 10;  
            }  
            return j;  
        }  
    }  

    ·回文数的定义:

    对于非负数 其左右两边完全相同 则是回文。 e.g: 121 11 等

    对于负数 其绝对值左右两边完全相同 则是回文。 e.g: -121 -11 等

    设计一个算法判断给定的数是否为回文数,如果是,输出true 反之 输出false;

    c++代码:

    #include <iostream>  
    #include <math.h>  
      
    using namespace std;  
      
    bool isPadlindrome(int n)  
    {  
        // 如果是int类型的最小值 显然不是回文数  
        if (n == INT_MIN)  
        {  
            return false;  
        }  
      
        // 绝对值  
        n = abs(n);  
      
        int tmp = 1;  
      
        // 将tmp位数变为与n一致  
        while(n / tmp >= 10) // 防止tmp溢出  
        {  
            tmp *= 10;  
        }  
      
        // n = 0 表示所有位比较完  
        while(n != 0)  
        {  
            // 最高位 != 最低位  
            if (n / tmp != n % 10)  
            {  
                return false;  
            }  
      
            // 最高位 = 最低位 去掉最高位 去掉最低位  
            // 继续比较  
            n = (n % tmp) / 10;  
            tmp /= 100;  
        }  
      
        return true;  
    }  
      
    int main(void)  
    {  
        int n;  
        cin>>n;  
      
        if (isPadlindrome(n))  
        {  
            cout<<"true"<<endl;  
        }  
        else  
        {  
            cout<<"false"<<endl;  
        }  
      
        return 0;  
    }  

    展开全文
  • Java 判断回文字符串

    2021-04-01 14:39:02
    Java 判断回文字符串
    package chapter3;
    import java.util.Scanner;
    /****************************************************************
     * Author:icyn
     * Description: 回文数字 is a palindrome
     * others:别忘了给游标 j设置成sNumber.length()-1
     * Date:2021/4/1 下午
     * Test:
    Enter a three-digit integer:
    121
    121 is a palindrome
    Enter a three-digit integer:
    123
    123 is not a palindrome
     * ***************************************************************
     */
    public class exc3_12 {
    	
    	public static void main(String[] args) {
    		
    		Scanner input=new Scanner(System.in);
    		
    		//将读入的字符串转换成字符数组
    		System.out.println("Enter a three-digit integer:");
    		String sNumber=input.next();
    		char[]   cArray=sNumber.toCharArray();
    		
    		int i=0,j=sNumber.length()-1;
    		
    		while(i<j&&cArray[i]==cArray[j]) {
    			i++;
    			j--;	
    		}
    		
    		if(i<j) {
    			System.out.println(sNumber+" is not a palindrome");
    		}else {
    			System.out.println(sNumber+" is a palindrome");
    		}
    		
    	}
    	
    }
    
    
    展开全文
  • 最后打印那部分我没做,如果有需要的同学...//回文字符串暴里破解法,求回文字符串长度 public class huiwen1 { public static void main(String[] args) { //写下字符串并拆分成数组 Scanner sc = new Scanner(Sys
  • 判断一个是否是回文字符串回文字符串是指正序(从左向右)和倒序(从右向左)读都是一样的字符串。 示例1: 输入: 121 输出: true 示例2: 输入: -121 输出: false 解释: 从左向右读, 为 -121 。 从...
  • java判断回文字符串的方法

    千次阅读 2020-03-20 22:49:31
    首先介绍下什么是回文字符串回文字符串就是关于中心对称的字符串,比如 测试下
  • Java实现回文字符串判断

    千次阅读 2017-03-22 10:11:56
    这里先说一下判断回文字符串的三种思路:递归、双指针以及字符串翻转1.双指针:即在字符串前后同时进行移动判断,对应位置上的字符是否相同:public boolean Palindrome(String s,int start,int end){ char[] c = s....
  • 回文字符串就是将该字符串进行逆序处理后,仍然与原字符串一样 如:abcdcba、12321、雾锁山头山锁雾 第一种方法 利用字符串的下标,判断第一个字符与最后一个字符是否相同,第二个字符与倒数第二个字符是否相同,...
  • java判断回文字符串的几种方法

    万次阅读 多人点赞 2014-07-22 16:45:43
    java判断回文字符串几种简单的实现: 1.将字符串倒置后逐一比较,实现如下: public class HuiWenTest { /** * @SERLIN */ public static void main(String[] args) { String str = ""; System.out....
  • 回文字符串 题目要求:  判断一个字符串是不是对称字符串。(用递归的方法) 代码: package 回文字符串; import java.util.Scanner; public class Huiwenzifuchuan { public static void main(String[] args...
  • 判断回文字符串: 设置两个指针,一个从左边开始遍历,另一个从右开始遍历,并设置哨兵,依次比较两个元素的值;两值相同则哨兵为true,进入下一次遍历,当左边遍历到右边,右边遍历到左边时跳出循环;(这里可以...
  • Java 判断字符串是否是回文字符串

    千次阅读 2019-09-16 21:35:20
    解决上述问题,有两种方法可供参考...(1)从字符串两头往中间扫; (2)从字符串中间往两头扫。 具体代码如下: import java.util.Scanner; public class StringPalindrome { //方法1:两头往中间扫 public bool...
  • 判断是否回文字符串方法一:传统两个指针 begin---end; str.charAt(begin)==str.charAt(end) 不能用str[begin]==str[end];没有这种用法; String str import java.util.Scanner; public class Main{ public ...
  • 判断是否是回文字符串 方法一: /** * 判断是否是回文字符串 */ public class test4 { public static void main(String[] args) { String str = "12321"; int first = 0; int last = str.length() - 1; ...
  • public static List<String> getStringhw(String hwstring){ List<String> list=new ArrayList<String>(); char[] chars = hwstring.toCharArray(); ... //得到一级字符串 ..
  • package lianxi; import java.util.*; public class Test37{ public static void main(String[]... if(huiwen(ss)) System.out.println("是回文字符串"); else System.out.println("不是是回文字符串"); } publi.
  • Java判断回文字符串

    2020-03-30 12:01:15
    public class Palindrome { public static boolean isPalindrome(String s) { int len = s.length(); for (int i = 0; i < len / 2; i++) if (s.charAt(i) != s.charAt(len - i...
  • 回文字符串

    2017-02-05 12:39:07
    回文字符串 时间限制:3000 ms | 内存限制:65535 KB 难度:4 描述所谓回文字符串,就是一个字符串,从左到右读和从右到左读是完全一样的,比如"aba"。当然,我们给你的问题不会再简单到判断一个字符串...
  • Java实现 LeetCode 680 验证回文字符串 Ⅱ(暴力)

    万次阅读 多人点赞 2020-04-04 17:12:44
    680. 验证回文字符串 Ⅱ 给定一个非空字符串 s,最多删除一个字符。判断是否能成为回文字符串。 示例 1: 输入: “aba” 输出: True 示例 2: 输入: “abca” 输出: True 解释: 你可以删除c字符。 注意: 字符串只包含...
  • JAVA:验证回文字符串

    2020-05-19 10:27:06
    JAVA:验证回文字符串问题思路代码 问题 思路 首先想到暴力枚举,先判断s是否为回文,若不是则一个一个删除,看新s是否为回文。思路没问题,时间复杂度过高,会超出时间限制。因为判断是否为回文遍历数组,再每个...
  • Java判断是否为回文字符串

    千次阅读 2019-08-03 09:55:28
    如:“A man, a plan, a canal: Panama” 是一段回文字符串 “race a car”则不是回文字符串 实现方法 从字符串的两端逐个进行比较,若遇到非字母或数字字符则将索引值加一或减一,如果两端字符不同,直接返回fals....
  • 给定一个字符串,验证它是否是回文串,只考虑字母和数字字符,可以忽略字母的大小写。 说明:本题中,我们将空字符串定义为有效的回文串。 示例 1: 输入: "A man, a plan, a canal: Panama" 输出: true 示例 ...
  • Java 获取最大回文字符串

    千次阅读 2014-05-27 21:49:42
    获取最大回文字符串也是笔记中常考到的一个题目
  • 验证回文字符串(java)

    2019-12-03 20:25:34
    3.验证回文字符串 题目 给定一个字符串,验证它是否是回文串,只考虑字母和数字字符,可以忽略字母的大小写。 说明:本题中,我们将空字符串定义为有效的回文串。 示例 1: 输入: "A man, a plan, a canal: Panama" ...
  • 判断回文字符串

    2021-01-15 22:01:26
    问题描述:如何判断回文字符串? 什么是回文字符串? 如果一个字符串从前向后读和从后向前读,都是一个字符串称为回文字符串。 例如:mom,dad,opo等。 package work_15; import java.util.Scanner; public class ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,536
精华内容 5,414
关键字:

java回文字符串

java 订阅