检查字符串是否为回文字符串

Question

检查字符串是否为回文字符串

95

一个回文是指一个单词、短语、数字或其他单元的序列，在任一方向上读取时都是相同的。

要检查一个单词是否为回文，我会获取该单词的字符数组并比较其字符。我测试过了，似乎可以正常工作。但是我想知道它是否正确，或者是否有什么需要改进的地方。

以下是我的代码：

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;
    }
}

- DarkLeafyGreen

4

不确定这是否是有意的，但您例子中的字符串 - reliefpfpfeiller - 不是回文。 - barrowc

44个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Chandara Chea · Answer 1

 public static boolean isPalindrome(String word) {
    String str = "";
    for (int i=word.length()-1; i>=0;  i--){
        str = str + word.charAt(i);
    }
   if(str.equalsIgnoreCase(word)){
       return true;
   }else{
       return false;
   }

}

- Felix · Answer 2

令人惊讶的是，对于一个如此简单的问题存在着如此多不同的解决方案！这里又有一个。

private static boolean palindrome(String s){
    String revS = "";
    String checkS = s.toLowerCase();
    String[] checkSArr = checkS.split("");

    for(String e : checkSArr){
        revS = e + revS;
    }

    return (checkS.equals(revS)) ? true : false;
}

- Angela Sanchez · Answer 3

private static boolean isPalindrome(String word) {

        int z = word.length();
        boolean isPalindrome = false;

        for (int i = 0; i <= word.length() / 2; i++) {
            if (word.charAt(i) == word.charAt(--z)) {
                isPalindrome = true;
            }
        }

        return isPalindrome;
    }

- Sotti · Answer 4

我正在寻找一个解决方案，不仅适用于回文，例如...

"Kayak"
"Madam"

...而且也适用于...

"A man, a plan, a canal, Panama!"
"Was it a car or a cat I saw?"
"No 'x' in Nixon"

迭代：这已被证明是一个很好的解决方案。

private boolean isPalindromeIterative(final String string)
    {
        final char[] characters =
            string.replaceAll("[\\W]", "").toLowerCase().toCharArray();

        int iteratorLeft = 0;
        int iteratorEnd = characters.length - 1;

        while (iteratorEnd > iteratorLeft)
        {
            if (characters[iteratorLeft++] != characters[iteratorEnd--])
            {
                return false;
            }
        }

        return true;
    }

递归。我认为这个解决方案不应该比迭代的差太多。有点烂是因为我们需要将清洗步骤从方法中提取出来以避免不必要的处理。

private boolean isPalindromeRecursive(final String string)
        {
            final String cleanString = string.replaceAll("[\\W]", "").toLowerCase();
            return isPalindromeRecursiveRecursion(cleanString);
        }

private boolean isPalindromeRecursiveRecursion(final String cleanString)
        {
            final int cleanStringLength = cleanString.length();

            return cleanStringLength <= 1 || cleanString.charAt(0) ==
                       cleanString.charAt(cleanStringLength - 1) &&
                       isPalindromeRecursiveRecursion  
                           (cleanString.substring(1, cleanStringLength - 1));
        }

反转: 这已被证明是一个昂贵的解决方案。

private boolean isPalindromeReversing(final String string)
    {
        final String cleanString = string.replaceAll("[\\W]", "").toLowerCase();
        return cleanString.equals(new StringBuilder(cleanString).reverse().toString());
    }

感谢在这篇文章中回答问题并为该主题带来光明的人们。

- Seyyed Mohsen Mousavi · Answer 5

 public boolean isPalindrome(String input) {
    char[] inputChars = input.toCharArray();
    int inputLength = inputChars.length;
    int inputMid = inputLength / 2;

    for (int i = 0; i <= inputMid; i++) {
        if (inputChars[i] != inputChars[inputLength - i - 1]) {
             return false;
        } 
    }
    return true;
}

该方法确定一个字符串输入是否为回文。在这个方法中，循环迭代的次数为输入长度的一半，从而减少了性能问题并使应用程序更加简洁。

- george mano · Answer 6

For循环包含sub.length() / 2 - 1。必须减去1，因为字符串中间的元素不需要被检查。

例如，如果我们要检查一个有7个字符的字符串（1234567），那么7/2 => 3，然后我们减去1，所以字符串中的位置将变为（0123456）。被检查的字符是0、1、2元素和6、5、4元素。我们不关心位置3上的元素，因为它正好在字符串的中间。

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

- Gorakh Nath · Answer 7

我们可以将循环减少到长度的一半：

function isPallindrome(s) {
  let word= s.toLowerCase();
  let length = word.length -1;
  let isPallindrome= true;
  for(let i=0; i< length/2 ;i++){
    if(word[i] !== word[length -i]){
      isPallindrome= false;
      break;
    }
  }
  return isPallindrome;
}

- Jaxadev · Answer 8

我创建了一个新的时间复杂度为7毫秒的Java解决方案，非常简单易懂！我从ASCII表中获取所需的数字和字母，不会触及其他内容，最后通过检查两个字符串是否相等来返回true或false。

StringBuilder newString = new StringBuilder();

    s = s.toLowerCase();

    for (char ch : s.toCharArray()) {

        if (97 <= (int) ch && (int) ch <= 122 || 48 <= (int)ch && (int)ch <= 57) {

            newString.append(ch);
        }
    }

    String nextS = new StringBuilder(newString).reverse().toString();
    
    return nextS.equals(newString.toString());

- rashedcs · Answer 9

代码片段：

import java.util.Scanner;

 class main
 {
    public static void main(String []args)
    {
       Scanner sc = new Scanner(System.in);
       String str = sc.next();
       String reverse = new StringBuffer(str).reverse().toString();

        if(str.equals(reverse))
            System.out.println("Pallindrome");
        else
            System.out.println("Not Pallindrome");
     }
}

- zarpio · Answer 10

在 PHP 中

function isPalindrome($string) {
    return (strrev($string) == $string) ? true : false;
}

var_dump(isPalindrome('madam')); //bool(true)
var_dump(isPalindrome('dell')); //bool(false)
var_dump(isPalindrome('1221')); //bool(true)