Leetcode isPalindrome失败

Question

我想知道如何让我的isPalindrome更快地传递leetcode中更大的字符串？这是input我的代码由于超出时间限制而失败。

import java.util.Stack;
public class Palindrome {
    public boolean isPalindrome(String s){
        Stack<Character> charStack = new Stack<Character>();
        String alphanumericStr="";
        for (int i=0; i<s.length(); i++){
            if (Character.isLetterOrDigit(s.charAt(i))){
                alphanumericStr=alphanumericStr+String.valueOf(s.charAt(i)).toLowerCase();
            }
        }
        System.out.println("str = [" + alphanumericStr + "]");
        if (alphanumericStr.length()==0 || alphanumericStr.length()==1){
            return true;
        }

        if (alphanumericStr.length()%2 == 0){
            if (s.charAt(s.length()/2) != s.charAt((s.length()/2) -1)){
                return false;
            }
        }
        System.out.println( (alphanumericStr.length()/2)-1 );
        for (int i=0; i< (alphanumericStr.length()/2);i++){

                charStack.push(alphanumericStr.charAt(i));

        }

        for (int i=(alphanumericStr.length()/2)+1; i<alphanumericStr.length(); i++){
            if (!charStack.empty()) {
                if (Character.isLetterOrDigit(alphanumericStr.charAt(i))) {
                    if (charStack.pop() != alphanumericStr.charAt(i)) {
                        return false;
                    }
                }
            }
        }
        return true;
    }

    public static void main (String[] argc){
        String mimim = "a.";
        Palindrome palindrome=new Palindrome();
        boolean res= palindrome.isPalindrome(mimim);
        System.out.println("result is  = [" + res + "]");
        return;
    }

}

Answer 1

这应该不是那么大的问题。使用堆栈可能会遇到大字符串的内存问题，但我说你根本不需要堆栈。

只需获取字符数组并使用两个索引来检查字符。从字符串的正面和背面开始，推进每个索引，直到你点击一个字母数字字符，检查并且两者是否相等而忽略了案例推进两者（当然你＆＃39; d＆＃34;提前＆＃34;一个索引向后启动从前面）。

如果字符不相等（字符串不是回文）或向后索引小于或等于正向索引，则停止。

修改：

另一种可能不是那么快但是更短的方法（在代码方面）将是：

//remove all non-alphanumeric chars
String forwardStr = yourString.replaceAll("[^a-zA-Z0-9]","");

//get a reversed version of the strinf
String revStr = new StringBuilder(forwardStr).reverse().toString();

//check equality ignoring case
boolean isPalindrome = forwardStr.equalsIgnoreCase( revStr );

Answer 2

关于leetcode的我的C＃解决方案

    var length = s.Length;

    if (length == 0) return false;

    var dic = new Dictionary<char, int>();

    for (var i = 0; i < length; i++)
    {
        if (dic.ContainsKey(s[i]))
        {
            dic[s[i]]++;
            continue;
        }

        dic.Add(s[i], 1);
    }

    var odd = 0;
    foreach (var pv in dic)
    {
        if (odd > 1) return false;
        if (pv.Value % 2 != 0) odd++;
    }

    //code reach here means string IsPpalindorme  
    //but when continue use dictionary build all palindrome permutation, i also had time limit exceeded with string like "aabbhijkkjih" my recursive method seems not right. 

Answer 3

代码的时间复杂度为O（N）。您可以尝试使用两个指针同时扫描输入字符串从两侧到中间。所以时间复杂度将下降到O（logN）。这是我的示例JAVA代码。

getMin (Min 1 <> Min 2) == 1
getMax (Max 1 <> Max 2) == 2

getMin (foldMap Min [1, 3, 5]) == 1
getMax (foldMap Max [1, 3, 5]) == 5

getMin *** getMax $ foldMap (Min &&& Max) [1, 3, 5]
==
(1, 5)

Answer 4

你的算法的Big-O只是O（n），只是你为循环使用了太多，所以它浪费了你很多时间。

如果您只想找到更好的leetcode问题解决方案，只需去讨论页面，他们确实有很多好的答案。

如果您仍未获得他们的想法，可以在StackOverFlow上查看

Answer 5

public boolean isPalindrome(String s) {
    char [] chars = s.toLowerCase().replaceAll("[^a-z0-9]", "").toCharArray();
    for (int i=0; i< chars.length; i++) {
        if (!Character.isLetterOrDigit(chars[i])){
            continue;
        }
        if (chars[i] != chars[chars.length-1 -i]) {
            return false;
        }
    }

    return true;

}

Answer 6

这是我的 C# 解决方案

public bool IsPalindrome(string s) {
        string str = s.ToLower();
        int left = 0;
        int right = s.Length -1 ;
        while(left <  right){
            while(!Char.IsLetter(str[left]) && 
                  !Char.IsDigit(str[left]) &&
                  left < right) left++;
            while(!Char.IsLetter(str[right]) && 
                  !Char.IsDigit(str[right]) &&
                  right > left) right--;
            
            if(left == s.Length - 1) return true;  
            
            if(str[left] == str[right]){
                                             
                left ++;
                right --;
                continue;
            }
            
            return false;
                 
            
        }
        
        return true;
    }