遞歸函數：檢查 Java 中的回文

Question

我有一個檢查字符串是否為回文的類。 我有兩個問題。

1）這是檢查回文的最有效方法嗎？ 2）這可以遞歸實現嗎？

public class Words {

    public static boolean isPalindrome(String word) {
    String pal = null;
    word = word.replace(" ", "");
    pal = new StringBuffer(word).reverse().toString();
    if (word.compareTo(pal) == 0) {
        return true;
    } else {
        return false;
    }

    }

}

有一個測試類來測試這個......懷疑它是否需要，但無論如何，如果有人願意嘗試它能夠幫助我解決上述兩個問題中的任何一個......

public class testWords {

    public static void main(String[] args) {
    if (Words.isPalindrome("a") == true) {
        System.out.println("true");
    } else {
        System.out.println("false");
    }
    if (Words.isPalindrome("cat") == true) {
        System.out.println("true");
    } else {
        System.out.println("false");
    }
    if (Words.isPalindrome("w o    w") == true) {
        System.out.println("true");
    } else {
        System.out.println("false");
    }
    if (Words.isPalindrome("   a  ") == true) {
        System.out.println("true");
    } else {
        System.out.println("false");
    }
    if (Words.isPalindrome("mom!") == true) {
        System.out.println("true");
    } else {
        System.out.println("false");
    }

    }

}

提前感謝您的任何幫助和/或輸入:)

Answer 1

要以遞歸方式實現“回文檢查”，您必須比較第一個和最后一個字符是否相同。 如果它們不相同，則字符串肯定不是回文。 如果它們相同，則字符串可能是回文，您需要將第二個字符與倒數第二個字符進行比較，依此類推，直到您的字符串中剩余的字符數嚴格少於 2 個。

遞歸算法如下所示：

public static boolean isPalindrome(String word) {
  //Strip out non-alphanumeric characters from string
  String cleanWord = word.replaceAll("[^a-zA-Z0-9]","");
  //Check for palindrome quality recursively
  return checkPalindrome(cleanWord);
}
private static boolean checkPalindrome(String word) {
  if(word.length() < 2) { return true;  }
  char first  = word.charAt(0);
  char last   = word.charAt(word.length()-1);
  if(  first != last  ) { return false; }
  else { return checkPalindrome(word.substring(1,word.length()-1)); }
}

• 請注意，我的遞歸方法不是最有效的方法，但易於理解

• Marimuthu Madasamy有更高效的遞歸方法，但更難理解

• Joe F列出了一個等效有效的迭代方法
  這是實現的最佳方法，因為它不會導致堆棧溢出錯誤

Answer 2

這是另一個遞歸解決方案，但使用數組可以在遞歸調用中為您提供優於字符串的性能優勢（避免substring或charAt ）。

private static boolean isPalindrome(final char[] chars, final int from,
        final int to) {
    if (from > to) return true;
    return chars[from] != chars[to] ? false 
                                    : isPalindrome(chars, from + 1, to - 1);
}

public static boolean isPalindrome(final String s) {
    return isPalindrome(s.toCharArray(), 0, s.length() - 1);
}

這個想法是我們跟蹤數組中的兩個位置，一個在開頭，另一個在結尾，我們不斷向中心移動這些位置。

當位置重疊並通過時，我們完成了所有字符的比較，並且到目前為止所有字符都匹配； 字符串是回文。

在每次通過時，我們比較字符，如果它們不匹配，則字符串不是回文，否則將位置移近。

Answer 3

實際上，僅檢查中間字符以確認它是回文就足夠了，這意味着您可以將其簡化為如下所示：

// Length of my string.
int length = myString.length();

// Loop over first half of string and match with opposite character.
for (int i = 0; i <= length / 2; i++) {
    // If we find one that doesn't match then return false.
    if (myString.charAt(i) != myString.charAt(length - 1 - i)) return false;
}

// They all match, so we have found a palindrome!
return true;

遞歸解決方案是非常可能的，但它不會給您帶來任何性能優勢（並且可能不那么可讀）。

Answer 4

這可以遞歸實現嗎？

是的
這是示例：

public static boolean palindrome(String str)
{
    if (str.length()==1 || str.length == 0)
    return true;
    char c1 = str.charAt(0);
    char c2 = str.charAt(str.length() - 1);
    if (str.length() == 2)
    {
        if (c1 == c2)
        return true;
        else
        return false;
    }
    if (c1 == c2)
    return palindrome(str.substring(1,str.length() - 1));
    else
    return false;
}

Answer 5

我的兩分錢。 看到人們解決問題的不同方式總是很高興的。 當然，這不是最有效的算法內存或速度。

public static boolean isPalindrome(String s) {

    if (s.length() <= 1) { // got to the middle, no need for more checks
        return true;
    }

    char l = s.charAt(0); // first char
    char r = s.charAt(s.length() - 1); // last char

    if (l == r) { // same char? keep checking
        String sub = s.substring(1, s.length() - 1);
        return isPalindrome(sub);
    }

    return false;
}

Answer 6

檢查回文的最簡單方法。

private static String palindromic(String word) {
    if (word.length() <= 1) {
        return "Polidramic";
    }else if (word.charAt(0) != word.charAt(word.length() - 1)) {
        return "Not Polidramic";
    }
    return palindromic(word.substring(1, word.length() - 1));
}