Vérifier le palindrome d'une chaîne de caractères

Question

A palindrome est un mot, une phrase, un nombre ou une autre séquence d'unités qui peut être lu de la même façon dans les deux sens.

Pour vérifier si un mot est un palindrome, je récupère le tableau de caractères du mot et je compare les caractères. Je l'ai testé et cela semble fonctionner. Cependant, je voudrais savoir si c'est correct ou s'il y a quelque chose à améliorer.

Voici mon code :

public class Aufg1 {
    public static void main(String[] args) {
        String wort = "reliefpfpfeiller";
        char[] warray = wort.toCharArray(); 
        System.out.println(istPalindrom(warray));       
    }

    public static boolean istPalindrom(char[] wort){
        boolean palindrom = false;
        if(wort.length%2 == 0){
            for(int i = 0; i < wort.length/2-1; i++){
                if(wort[i] != wort[wort.length-i-1]){
                    return false;
                }else{
                    palindrom = true;
                }
            }
        }else{
            for(int i = 0; i < (wort.length-1)/2-1; i++){
                if(wort[i] != wort[wort.length-i-1]){
                    return false;
                }else{
                    palindrom = true;
                }
            }
        }
        return palindrom;
    }
}

Answer 1

Pourquoi ne pas simplement :

public static boolean istPalindrom(char[] word){
    int i1 = 0;
    int i2 = word.length - 1;
    while (i2 > i1) {
        if (word[i1] != word[i2]) {
            return false;
        }
        ++i1;
        --i2;
    }
    return true;
}

Ejemplo:

L'entrée est "andna".
i1 sera égal à 0 et i2 à 4.

Lors de la première itération de la boucle, nous allons comparer word[0] y word[4] . Ils sont égaux, donc nous incrémentons i1 (il est maintenant égal à 1) et décrémentons i2 (il est maintenant égal à 3).
On compare alors les n. Ils sont égaux, donc nous incrémentons i1 (il est maintenant égal à 2) et décrémentons i2 (il est égal à 2).
Maintenant i1 et i2 sont égaux (ils sont tous les deux 2), donc la condition de la boucle while n'est plus vraie, donc la boucle se termine et nous retournons true.

Answer 2

Vous pouvez vérifier si une chaîne est un palindrome en la comparant à l'inverse d'elle-même :

public static boolean isPalindrome(String str) {
    return str.equals(new StringBuilder(str).reverse().toString());
}

ou pour les versions de Java antérieures à la version 1.5,

public static boolean isPalindrome(String str) {
    return str.equals(new StringBuffer().append(str).reverse().toString());
}

EDIT : @FernandoPelliccioni fourni une analyse très approfondie de l'efficacité (ou du manque d'efficacité) de cette solution, tant en termes de temps que d'espace. Si vous êtes intéressé par la complexité informatique de cette solution et d'autres solutions possibles à cette question, lisez-le !

Answer 3

Une version concise, qui n'implique pas l'initialisation (inefficace) d'un tas d'objets :

boolean isPalindrome(String str) {    
    int n = str.length();
    for( int i = 0; i < n/2; i++ )
        if (str.charAt(i) != str.charAt(n-i-1)) return false;
    return true;    
}

Answer 4

Alternativement, récursion .

Pour tous ceux qui cherchent une solution récursive plus courte, pour vérifier si une chaîne de caractères donnée peut être considérée comme un palindrome :

private boolean isPalindrome(String s) {
    int length = s.length();

    if (length < 2) // If the string only has 1 char or is empty
        return true;
    else {
        // Check opposite ends of the string for equality
        if (s.charAt(0) != s.charAt(length - 1))
            return false;
        // Function call for string with the two ends snipped off
        else
            return isPalindrome(s.substring(1, length - 1));
    }
}

---

OU même plus court si vous le souhaitez :

private boolean isPalindrome(String s) {
    int length = s.length();
    if (length < 2) return true;
    return s.charAt(0) != s.charAt(length - 1) ? false :
            isPalindrome(s.substring(1, length - 1));
}

Answer 5

Allez, Java :

public boolean isPalindrome (String word) {
    String myWord = word.replaceAll("\\s+","");
    String reverse = new StringBuffer(myWord).reverse().toString();
    return reverse.equalsIgnoreCase(myWord);
}

isPalindrome("Never Odd or Even"); // True
isPalindrome("Never Odd or Even1"); // False