精华内容
下载资源
问答
  • java字符串最长回文串Given a string and we have to check whether it is palindrome string or not. 给定一个字符串,我们必须检查它是否是回文字符串。 A string that is equal to its reverse string is known...

    java字符串最长回文串

    Given a string and we have to check whether it is palindrome string or not.

    给定一个字符串,我们必须检查它是否是回文字符串。

    A string that is equal to its reverse string is known as palindrome string. To implement the program for checking whether a given string is a palindrome or not, we have created a function "isPalindrome()".

    等于其反向字符串的字符串称为回文字符串 。 为了实现检查给定字符串是否为回文程序 ,我们创建了一个函数“ isPalindrome()”

    In the function,

    在功能上

    • We are checking for whether a string is an empty string or not – if the string is an empty string then throwing an error.

      我们正在检查一个字符串是否为空字符串-如果该字符串为空字符串,则抛出错误。

    • Then, we are converting string to uppercase to make comparison case insensitive.

      然后,我们将字符串转换为大写以使比较大小写不敏感。

    • Then, running a loop from 0 to len/2, to compare the first character with last character, the second character with second last character and so on..., and checks whether they are equal or not if both the elements are equal it goes for the next one. If not, then code returns false. Going on comparing first and last elements of the string if it reaches the length/2 mark then the loop ends, and return true for Palindrome.

      然后,从0到len / 2循环运行,比较第一个字符与最后一个字符,第二个字符与倒数第二个字符,依此类推...,并检查两个元素是否相等,是否相等?去下一个。 如果不是,则代码返回false。 继续比较字符串的第一个和最后一个元素(如果它达到length / 2标记),则循环结束,并为回文式返回true。

    用于检查字符串回文的Java代码 (Java code for checking string palindrome)

    // Java code for checking string palindrome 
    
    public class Main {
        //function to check whether string is Palindrome or not
        public static boolean isPalindrome(String str) {
            // Checking for null
            if (str == null) {
                throw new IllegalArgumentException("String is null.");
            }
    
            // length of the string
            // if there is one character string - returing true
            int len = str.length();
            if (len <= 1) {
                return true;
            }
    
            // Converting the string into uppercase 
            // to make the comparisons case insensitive 
            String strU = str.toUpperCase();
    
            // result variable
            // default initializing it with true
            boolean result = true;
    
            for (int i = 0; i < len / 2; i++) {
                if (strU.charAt(i) != strU.charAt(len - 1 - i)) {
                    result = false;
                    // break the loop if the condition is true
                    break;
                }
            }
            return result;
        }
    
        //main code  
        public static void main(String[] args) {
            String str1 = "Hello world!";
            if (isPalindrome(str1)) {
                System.out.println(str1 + " is a palindrome string ");
            } else {
                System.out.println(str1 + " is not a palindrome string ");
            }
    
            String str2 = "ABCxCBA";
            if (isPalindrome(str2)) {
                System.out.println(str2 + " is a palindrome string ");
            } else {
                System.out.println(str2 + " is not a palindrome string ");
            }
    
            String str3 = "noon";
            if (isPalindrome(str3)) {
                System.out.println(str3 + " is a palindrome string ");
            } else {
                System.out.println(str3 + " is not a palindrome string ");
            }
    
            String str4 = "nooN";
            if (isPalindrome(str4)) {
                System.out.println(str4 + " is a palindrome string ");
            } else {
                System.out.println(str4 + " is not a palindrome string ");
            }
        }
    }
    
    

    Output

    输出量

    Hello world! is not a palindrome string
    ABCxCBA is a palindrome string
    noon is a palindrome string
    nooN is a palindrome string
    
    
    

    翻译自: https://www.includehelp.com/java-programs/string-palindrome-program-in-java.aspx

    java字符串最长回文串

    展开全文
  • 给定字符串最长回文子串

    千次阅读 2015-03-28 22:32:55
    问题描述:求给定字符串最长回文子串,比如输入字符串 "google”,该字符串的回文子串有"oo"和”goog",因此输出“goog"。 解决思路:反转字符串后求反转的字符串与原字符串的最长公共子串,这个最长的公共子串...

    问题描述:求给定字符串的最长回文子串,比如输入字符串 "google”,该字符串的回文子串有"oo"和”goog",因此输出“goog"。

    解决思路:反转字符串后求反转的字符串与原字符串的最长公共子串,这个最长的公共子串就是所求的最长回文子串

    注意:上面的思路有陷阱,这样求解是错误的。当 S=“abacdfgdcaba”, 那么S’ = “abacdgfdcaba”。 这样S和S‘的最长公共子串是abacd。很明显abacd并不是S的最长回文子串,它甚至连回文都不是。

    #include "stdafx.h"
    #include <stdio.h>
    #include <string>
    #include <vector>
    #include <iostream>
    using namespace std;
    
    string getLongestPaString(string s)
    {
        string inv_s = "";
        const char* ss = s.c_str();  
        int len = strlen(ss);  
        if(len==0)  
            return inv_s; 
        inv_s = s;
        for(int i=0;i<len;i++)
        {
    	inv_s.at(len-i-1) = s.at(i);
        }
        vector<int> pa_length;
        int max_pa_length = 0;
        int max_pa_flag   = -1;
        for(int i=0;i<len;i++)
        {
    		int tmp = 0;
    		int max_tmp=0;
    		int tmp_i = i;
    		for(int j=0;j<len;j++)
    		{
    			int tmp_j = j;
    			while(tmp_i<len && tmp_j<len && (s[tmp_i] == inv_s[tmp_j]) )
    			{
    				tmp_i++;
    				tmp_j++;
    				tmp++;
    				max_tmp = max(tmp,max_tmp);
    			}
    			tmp_i = i;
    			tmp = 0;
    		}
    		pa_length.push_back(max_tmp);
    		if(max_tmp > max_pa_length)
    		{
    			max_pa_length = max_tmp;
    			max_pa_flag = i;
    		}
        }
        string max_pa =s.substr(max_pa_flag,max_pa_length);
        return max_pa;
    	
    }
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	string ss = "wfree";
    	string a = getLongestPaString(ss);
    	cout<<a<<endl;
    	system("pause");
    	return 0;
    }
    

    这是个比较容易理解的思路,但算法的时间复杂度为O(n^3),还有待优化。

    注意:上面的算法不能完美得出最长回文子串,原串中含有一个非回文的串的反序串的时候,最长公共子串的解法就是不正确的,留着当个警告吧!

    在网上还看到其他几种求一个字符串的最长回文子串的方法,准备抽时间实现看看。

    1、最容易想到的就是遍历整个字符串,然后求出以每个字符为中心的最长回文串(要考虑奇数和偶数问题),这样的时间复杂度为O(n^2);

    2、还有一种就是用后缀数组的方法,将字符串倒转过来然后接到原字符串的后面构造一个新串,中间用一个原字符串中没出现的字符做分隔符,求原字符串最长回文字串就相当于求新串后缀数组的最长公共前缀了,代码较复杂,时间复杂度为O(nlgn);

    3、另一种方法时用manacher算法:这个算法有一个很巧妙的地方,它把奇数的回文串和偶数的回文串统一起来考虑了。这一点一直是在做回文串问题中时比较烦的地方。这个算法还有一个很好的地方就是充分利用了字符匹配的特殊性,避免了大量不必要的重复匹配。



    展开全文
  • 给定字符串A以及它的长度n,请返回最长回文子串的长度。 测试样例: "abc1234321ab",12 返回:7 CODE 暴力求解一: # -*- coding:utf-8 -*- class Palindrome: def getLongestPalindrome(self, A, n): # ...

    题目描述

    对于一个字符串,请设计一个高效算法,计算其中最长回文子串的长度。

    给定字符串A以及它的长度n,请返回最长回文子串的长度。

    测试样例:

    "abc1234321ab",12
    返回:7

    CODE

    • 暴力求解一:
      2682ms5752KB
    # -*- coding:utf-8 -*-
    
    class Palindrome:
        def getLongestPalindrome(self, A, n):
            # write code here
            if n <= 1:
                return n
            s = int(n /2)
            max_n = 0
            arr = list(A)
            for i in range(n-1):
                i += 1
                step = min(s, n - i)
                for j in range(step):
                    j+=1
                    c = arr[i]
                    tr = arr[i+1 : i+j+1]
                    tl = arr[i+1 : i+j+1]
                    tl.reverse()
                    c1 = []
                    c2 = []
                    c1.extend(tl)
                    c1.extend(c)
                    c1.extend(tr)
    
                    c2.extend(tl)
                    c2.extend(c)
                    c2.extend(c)
                    c2.extend(tr)
    
                    if ("".join(c1) in A):
                        max_n = max(max_n, len(c1))
                    elif ("".join(c2) in A):
                        max_n = max(max_n, len(c2))
            return max_n
    • 暴力求解二:
      211ms32072KB
     public int getLongestPalindrome(String s) {
            if(s == null){
                return 0;
            }
            if(s.length() <= 1)
                return s.length();
            String res=s.substring(0,1);
            for (int i = 0; i < s.length(); i++) {
                for (int j = i + 1; j <= s.length(); j++) {
                    String k=s.substring(i,j);
                    String rk=new StringBuffer(k).reverse().toString();
                    if(k.equals(rk)&&k.length()>res.length()){
                        res=k;
                    }
                }
    
            }
            return res.length();
        }
    
    • 暴力求解三:
      115ms29352KB
    public int getLongestPalindrome(String s) {
            if (s == null)
                return 0;
            if(s.length() <= 1)
                return s.length();
            for(int i = s.length();i > 0; i--) {//子串长度
                for (int j = 0; j <= s.length() - i; j++) {
                    String sub = s.substring(j , i + j);//子串位置
                    int count = 0;//计数,用来判断是否对称
                    for (int k = 0; k < sub.length() / 2; k++) {//左右对称判断
                        if (sub.charAt(k) == sub.charAt(sub.length() - k - 1))
                            count++;
                    }
                    if (count == sub.length() / 2)
                        return sub.length();
                }
            }
            return 1;
    
        }
    • 动态规划:
      38ms11376KB
        public int getLongestPalindrome(String s) {
            if (s == null) {
                return 0;
            }
    
            if (s.length() <= 1) {
                return s.length();
            }
            int n = s.length();
            boolean[][] dp = new boolean[n][n];
            int left = 0;
            int right = 0;
            for (int i = n - 2; i >= 0; i--) {
                dp[i][i] = true;
                for (int j = i + 1; j < n; j++) {
                    dp[i][j] = s.charAt(i) == s.charAt(j) &&( j-i<3||dp[i+1][j-1]);//小于3一定是回文
                    if(dp[i][j]&&right-left<j-i){
                        left=i;
                        right=j;
                    }
                }
            }
            return right - left + 1;
        }
    
    public int getLongestPalindrome(String s) {
            if (s == null) {
                return 0;
            }
    
            if (s.length() <= 1) {        
                return s.length();
            }
    
            List<Character> s_new = new ArrayList<>();
            for(int i = 0;i < s.length();i++){
                s_new.add('#');
                s_new.add(s.charAt(i));
            }
            s_new.add('#');
            List<Integer> Len = new ArrayList<>();
            String sub = "";//最长回文子串
            int sub_midd = 0;//表示在i之前所得到的Len数组中的最大值所在位置
            int sub_side = 0;//表示以sub_midd为中心的最长回文子串的最右端在S_new中的位置
            Len.add(1);
            for(int i = 1;i < s_new.size();i++){
                if(i < sub_side) {//i < sub_side时,在Len[j]和sub_side - i中取最小值,省去了j的判断
                    int j = 2 * sub_midd - i;
                    if(j >= 2 * sub_midd - sub_side &&  Len.get(j) <= sub_side - i){
                        Len.add(Len.get(j));
                    }
                    else
                        Len.add(sub_side - i + 1);
                }
                else//i >= sub_side时,从头开始匹配
                    Len.add(1);
                while( (i - Len.get(i) >= 0 && i + Len.get(i) < s_new.size()) && (s_new.get(i - Len.get(i)) == s_new.get(i + Len.get(i))))
                    Len.set(i,Len.get(i) + 1);//s_new[i]两端开始扩展匹配,直到匹配失败时停止
                if(Len.get(i) >= Len.get(sub_midd)){//匹配的新回文子串长度大于原有的长度
                    sub_side = Len.get(i) + i - 1;
                    sub_midd = i;
                }
            }
            sub = s.substring((2*sub_midd - sub_side)/2,sub_side /2);//在s中找到最长回文子串的位置
            return sub.length();
    
        }

    思想

    参考文章:https://blog.csdn.net/SeaSky_Steven/article/details/108603928

    展开全文
  • 什么是回文?通俗来讲就是一段字符串,正着读和反着读都是一样的。例如aba,abccba。会发现回文是很完美的对称字符串。本文就是用代码找到这个最长回文

    题目:求解给定字符串的最长回文子串

    分析:什么是回文?通俗来讲就是一段字符串,正着读和反着读都是一样的。例如aba,abccba。会发现回文是很完美的对称字符串。

    解决方案一:暴力破解

    具体实现:求出给定字符串的所有的子串,针对每个子串与其倒置的串进行比较,若相等就是回文。

    private static void getHuiwenString(String input){
            for(int i=0; i<input.length();i++){
                StringBuilder stringBuilder =new StringBuilder();
                stringBuilder.append(input.charAt(i));
                if(stringBuilder.toString().equals(stringBuilder.reverse().toString())){
                    System.out.println(stringBuilder.toString());
                }
                for(int j=i+1; j<input.length(); j++){
                    stringBuilder.append(input.charAt(j));
                    if(stringBuilder.toString().equals(stringBuilder.reverse().toString())){
                        System.out.println(stringBuilder.toString());
                    }
                }
            }
        }

    解决方案二:Manacher算法

    具体实现:将原有的字符串进行改造,字符串中的两两字符之间插入一个桩(这个可以用一个特殊字符代替),这样的好处是无论原有的字符串的长度是奇数还是偶数,经过改造后都变成了奇数。例如我在文章开头举的例子:aba,abccba,就变成了#a#b#a#,#a#b#c#c#b#a#。这样字符串都有了一个中心。求解回文就是选中某个点然后向两边扩展,如果左右两边的字符相等就继续扩展,否则就退出。

    public class HuiWen {
        public static void main(String[] args) {
            String input = "abbabbaabb";
            StringBuilder stringBuilder = new StringBuilder();
            for (int i = 0; i < input.length(); i++) {
                stringBuilder.append("#");
                stringBuilder.append(input.charAt(i));
            }
    
            stringBuilder.append("#");
    
            System.out.println(stringBuilder);
    
            input = stringBuilder.toString();
    
            for (int i = 0; i < input.length(); i++) {
                String myString = getLongestString(input, i).replaceAll("#","");
                if(StringUtils.isNotEmpty(myString)){
                    System.out.println(myString);
                }
            }
    
        }
    
        private static String getLongestString(String input, int mid) {
            int len = input.length();
            StringBuilder stringBuilderLeft = new StringBuilder();
            StringBuilder stringBuilderRight = new StringBuilder();
            stringBuilderRight.append(input.charAt(mid));
            for (int i = mid, j = mid; i > 0 && j<len-1; i--, j++) {
                if (input.charAt(i - 1) != input.charAt(j + 1)) {
                    return stringBuilderLeft.reverse().append(stringBuilderRight).toString();
                }
    
                stringBuilderLeft.append(input.charAt(i - 1));
                stringBuilderRight.append(input.charAt(j + 1));
            }
    
            return stringBuilderLeft.reverse().append(stringBuilderRight).toString();
        }
    }

    总结

    暴力破解法两次for循环,时间复杂度就是O(n2),验证是否是回文,最多就是O(n3)。Manacher算法只需要一遍循环,再加上一遍扩展,时间复杂度最多是O(n2)。当字符串长度比较短时,确实看不出来谁优谁劣,但字符串很长时,就会发现暴力破解法会找出很多非最长回文的字符串,此外,Manacher算法还有优化的空间,例如如果找到已有的最长的回认为文长度超过后续锚点位置两边能扩展的最大长度,即可认为这就是最长回文。

    展开全文
  • a,aa,aba,abba const longestPalindrome = function (s) { // 如果 s 为 ''、 null、undefined,或者只有一个字符,则... // 已当前一个/两个字符为中心,向两边寻找最长回文字符串 const centerExpend = (left, r
  • 字符串最长回文

    2020-08-26 00:14:44
    给定一个字符串 s,找到 s 中最长回文子串。你可以假设 s 的最大长度为 1000。 示例 1: 输入: “babad” 输出: “bab” 注意: “aba” 也是一个有效答案。 示例 2: 输入: “cbbd” 输出: “bb” class Solution ...
  •  求给定字符最长回文串 思路:  将非给定字符离散成不同的值即可 代码: #include using namespace std; const int MAXN=210000; char ch[]={'A', 'H', 'I', 'M', 'O', 'T', 'U', 'V', 'W', 'X', 'Y'}; ...
  • 字符串最长回文算法

    千次阅读 2017-11-02 15:04:18
    Manacher算法 算法总结第三弹 manacher算法,前面讲了两个字符串相算法——kmp和拓展kmp,这次来还是来总结一个字符串算法,manacher算法,我习惯叫他 ...Manacher算法是查找一个字符串最长回文子串的线性算法
  • 字符串最长回文子串

    2018-11-07 18:13:22
    给定字符串str,若s同时满足以下条件: s是str的子串 s是回文串 则,s是str的回文子串。 算法的要求,是求str中最长的那个回文子串。 算法详解 第一种:枚举中心方法 循环索引,判断以某索引位开始判断前一半...
  • 给定一个字符串,若是回文字符串则返回该字符串,否则补充该字符串成为回文字符串 def func(s: str): """ 给定一个字符串,若是回文字符串则返回该字符串,否则补充该字符串成为回文字符串 例如: case1: ...
  • 字符串最长回文实现

    2019-03-30 01:42:57
    NULL 博文链接:https://louhaiyun.iteye.com/blog/1328996
  • 现在给定字符串“er0reviver”要求给出字符串内最长回文。写出代码输出结果。 Java: public static String longestPalindrome(String str) { int length = str.toCharArray().length; int resultLengt...
  • 字符串来说,将其逆序后仍能跟自己相等即为回文。例如 “asdsa”.代码如下:import java.util.HashSet; import java.util.Iterator; import java.util.Set; import java.util.Stack;public class Test { //判断该...
  • 5. Longest Palindromic Substring 这个是在本机测试,然后一次点亮的,嘻嘻 1 char* longestPalindrome(char* s) { 2 char *p = s; /* first char */ 3 char *left, *right; /* sto...
  • 2、遍历给定字符串,比较两种情况回文子串的长度 3、使用位运算符求差值从而取得该最长回文子串的始末索引 4、返回上述始末索引的子字符串,即为所求最长回文子串 3、解题代码 /** * @param {string} s * @return ...
  • 给定一个包含大写字母和小写字母的字符串找到通过这些字母构造成的最长回文串。 在构造过程中,请注意区分大小写。比如"Aa"不能当做一个回文字符串。 注意: 假设字符串的长度不会超过 1010。 示例 1: 输入: ...
  • 给定一个字符串s,你可以从中删除一些字符,使得剩下的串是一个回文串。如何删除才能使得回文串最长呢? 输出需要删除的字符个数。经典编程题目啦~~设原字符串s 原字符串反转的字符串t,回文串最长长度问题转为求...
  • 题目描述:给定一个字符串str,如果可以在str的任意位置添加字符,请返回在添加字符最少的情况下,让str整体都是回文字符串的一种结果。 示例: 输入:“zzazz” 输出:“zzazz” 输入:“abca” 输出:“acbca” ...
  • 题目给定一个字符串,找出该字符串最长回文子串。回文字符串指的就是从左右两边看都一样的字符串,如aba,cddc都是回文字符串字符串abbacdc存在的回文子串有abba和cdc,因此它的最长回文子串为abba。代码public ...
  • 找出给定字符串中的最长回文字符串 ##举例子: “ababd”, 返回 “abab” “BBBBBB”, 返回"B" 解法是从上一题学的,自动迁移,使用temp来存储遍历过的字符,然后遍历给定字符串,遇见遍历过的字符,那么自动开始...
  • 给定字符串A以及它的长度n,请返回最长回文子串的长度。 示例1 输入 “abc1234321ab”,12 返回值 7 解题思路 这个题目使用动态规划的思路做比暴力搜索效率高 动态规划思路: 首先我们知道回文串颠倒和不颠倒的...
  • 基本的想法是遍历所有的回文的支点范围从第一个字符的字符串字符串的最后一个字符的。使用StringBuilder来降低空间复杂度。 (考虑偶数与奇数长度的情况--我们也可以在每个字符中间插入特殊字符如# 来...
  • 找到字符串中的最长回文子串Problem statement: 问题陈述: Given a string you have to find out the longest palindromic subsequence from the given string. 给定一个字符串,您必须从给定字符串中找出最长...
  • 给定一个字符串,找出该字符串最长回文子串。回文字符串指的就是从左右两边看都一样的字符串,如aba,cddc都是回文字符串字符串abbacdc存在的回文子串有abba和cdc,因此它的最长回文子串为abba。 中心法求最长...
  • 找到字符串中的最长回文子串Problem statement: 问题陈述: Given a string you have to find out the length of the longest palindromic subsequence from the given string. 给定一个字符串,您必须从给定的...
  • 给定一个字符串,你的任务是计算这个字符串中有多少个回文子串。 具有不同开始位置或结束位置的子串,即使是由相同的字符组成,也会被计为是不同的子串。 示例 1: 输入: "abc" 输出: 3 解释: 三个回文子串: "a", "b...
  • 给定一个字符串查找最长回文子串 输入一个字符串,求出其中最长的回文子串。 子串的含义是:在原串中连续出现的字符串片段。 回文的含义是:子串从左向右看和从右向左看是相同的,例如:abba,yyxyy。 在判断...
  • 题目一:给定一个包含大写字母和小写字母的字符串找到通过这些字母构造成的最长回文串。 在构造过程中,请注意区分大小写。比如 “Aa” 不能当做一个回文字符串。 注意: 假设字符串的长度不会超过 1010。 示例 ...
  • LeetCode-字符串最长回文子串

    热门讨论 2019-02-13 09:02:56
    给定一个字符串 s,找到 s 中最长回文子串。你可以假设 s 的最大长度为 1000。 示例 输入1: 输入: "babad" 输出: "bab" 注意: "aba" 也是一个有效答案。 输入2...
  • 根据给定字符串是,找到最长回文子串。 示例1: 输入:“babad” 输出:“bab,”aba" 示例2: 输入:“cbbd” 输出:“bb” 具体实现过程如下: import java.util.ArrayList; import java.util.List; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,234
精华内容 4,093
关键字:

找到给定字符串的最长回文