Question

我写了一个函数来查找给定的字符串（去掉空格）是否是回文。不幸的是，运行需要很长时间。任何想法如何使下面的代码运行得更快？（我正在关注LeetCode的在线评委）：

public class Solution {

    public boolean checkIfPalindrome(String s) {
        if (s.length() == 0 || s.length() == 1) {
            return true;
        }
        //if first letter == last letter
        char first = s.charAt(0);
        char second = s.charAt(s.length() - 1);
        if (first == second) {
            String shorterString = s.substring(1, s.length() - 1);
            return isPalindrome(shorterString);
        } else {
            return false;
        }
    }

    public String onlyCharacters(String s) {
        String toReturn = "";
        for (Character c : s.toCharArray()) {
            if (Character.isLetter(c)) {
                toReturn += c;
            }
        }
        return toReturn;
    }

    public boolean isPalindrome(String s) {
        s = onlyCharacters(s);
        return checkIfPalindrome(s);
    }
}

Answer 1

这不是查找string是否为回文的最佳方式。

只需循环n/2次迭代（其中n的长度为string）并检查位置i处的字符是否等于位置n-i处的字符

Answer 2

如果字符串Dim SUITS As String SUITS = ChrW$(9824) & ChrW$(9827) & ChrW$(9829) & ChrW$(9830) ' ♠♣♥♦的长度为s，那么n将是一个回文，如果

代码：

s[i]=s[n-1-i] for i in range [0,ceil(n/2)]  // 0 based index

Answer 3

这是一种名为＆＃34;分而治之的算法方法＆＃34;。但在这种情况下，只需将其设为n / 2而不是n。

Answer 4

这是一个合适的算法，可能会有所帮助：

1.For i = 1 to n/2

2.如果string[i] = string[n-1]然后continue在循环中

3.Else break和return false

4。return true

Answer 5

您可以使用此StringBuilder.reverse()来检查Palindrome：

    private boolean isPalindrome(String str) {
       StringBuilder strBuilder = new StringBuilder(str);
       return str.equals(strBuilder.reverse().toString());
    }

Answer 6

如果n是输入字符串的长度，则代码需要进行O（n ^ 2）次操作。这可能会让您感到惊讶，因为您的代码中没有嵌套循环，但是字符串的substring方法和+ =运算符都需要创建一个新的String，这需要复制其内容。

为了看到这一点，我已插入

System.out.println(s);

进入isPalindrome()和checkIfPalindrome()方法，并调用

isPalindrome("doc, note: i dissent. a fast never prevents a fatness. i diet on cod");

这会产生以下输出：

docnoteidissentafastneverpreventsafatnessidietoncod
ocnoteidissentafastneverpreventsafatnessidietonco
ocnoteidissentafastneverpreventsafatnessidietonco
cnoteidissentafastneverpreventsafatnessidietonc
cnoteidissentafastneverpreventsafatnessidietonc
noteidissentafastneverpreventsafatnessidieton
noteidissentafastneverpreventsafatnessidieton
oteidissentafastneverpreventsafatnessidieto
oteidissentafastneverpreventsafatnessidieto
teidissentafastneverpreventsafatnessidiet
teidissentafastneverpreventsafatnessidiet
eidissentafastneverpreventsafatnessidie
eidissentafastneverpreventsafatnessidie
idissentafastneverpreventsafatnessidi
idissentafastneverpreventsafatnessidi
dissentafastneverpreventsafatnessid
dissentafastneverpreventsafatnessid
issentafastneverpreventsafatnessi
issentafastneverpreventsafatnessi
ssentafastneverpreventsafatness
ssentafastneverpreventsafatness
sentafastneverpreventsafatnes
sentafastneverpreventsafatnes
entafastneverpreventsafatne
entafastneverpreventsafatne
ntafastneverpreventsafatn
ntafastneverpreventsafatn
tafastneverpreventsafat
tafastneverpreventsafat
afastneverpreventsafa
afastneverpreventsafa
fastneverpreventsaf
fastneverpreventsaf
astneverpreventsa
astneverpreventsa
stneverprevents
stneverprevents
tneverprevent
tneverprevent
neverpreven
neverpreven
everpreve
everpreve
verprev
verprev
erpre
erpre
rpr
rpr
p
p

这是我们要求计算机计算的一面墙！我们还看到每个String都创建了两次。那是因为你在每次迭代中不必要地调用了只有角色（）。

为避免创建中间String实例，可以使用String Builder：

String onlyCharacters(String s) {
    StringBuilder toReturn = new StringBuilder();
    for (Character c : s.toCharArray()) {
        if (Character.isLetter(c)) {
            toReturn.append(c);
        }
    }
    return toReturn.toString();
}

另外，事实证明StringBuilder有一个名为reverse（）的酷方法，所以我们可以将你的程序简化为：

boolean isPalindrome(String s) {
    StringBuilder letters = new StringBuilder();
    for (Character c : s.toCharArray()) {
        if (Character.isLetter(c)) {
            letters.append(c);
        }
    }
    StringBuilder reversedLetters = new StringBuilder(letters).reverse();
    return onlyLetters.equals(reversedLetters);
}

此代码仅创建2 StringBuilder对象而不是n字符串，因此比代码快n/2倍。

Answer 7

我发现这比其他任何答案都要快：

<b:badge>

您只有一个对象：原始public class Solution { public boolean isPalindrome(String s) { for (int low = 0, high = s.length() - 1;; low++, high--) { char cLow = 0, cHigh = 0; // Find the next acceptable character for the increasing index. while (low < high && !Character.isLetterOrDigit(cLow = s.charAt(low))) { low++; } // Find the previous acceptable character for the decreasing index. while (low < high && !Character.isLetterOrDigit(cHigh = s.charAt(high))) { high--; } if (low >= high) { // All previous character comparisons succeeded and we have a palindrome. return true; } if (Character.toUpperCase(cLow) != Character.toUpperCase(cHigh)) { // This is not a palindrome. return false; } } } }。每个角色都经过测试，直到我们得到可接受的角色（String）。然后只有那些被比较。

没有临时对象，没有超级支票。直接达到目标：它做了一件事，但做得很好。

注意：这可以通过检查字母数字而不仅仅是字母而不关心案例来回答实际的Leetcode OJ答案。

Java：Palindrome发现太长;如何优化？

7 个答案: