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

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 提供, 点击上面的

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

- Oleg Cherednik · Answer 1

时间复杂度：O(n) 空间复杂度：O(1)

public static boolean isPalindrome(String str) {
    for (int i = 0, j = str.length() - 1; i < j; i++, j--)
        if (str.charAt(i) != str.charAt(j))
        // for case insesitive comapre
        // if (Character.toLowerCase(str.charAt(i)) != Character.toLowerCase(str.charAt(j)))
            return false;

    return true;
}

- lczapski · Answer 2

使用 Stream API:

private static boolean isPalindrome(char[] warray) {
    return IntStream.range(0, warray.length - 1)
            .takeWhile(i -> i < warray.length / 2)
            .noneMatch(i -> warray[i] != warray[warray.length - 1 - i]);
}

- ykb · Answer 3

import java.io.*;
import java.util.*;

public class Solution {

    public static void main(String[] args) {

        Scanner sc=new Scanner(System.in);
        String A=sc.next();
        char[] array = A.toCharArray();
        String str = "";
        for(int i=A.length()-1;i>=0;i--){
            str = str + array[i];
        }
        if(A.equalsIgnoreCase(str))System.out.println("Yes");
        else System.out.println("No");
    }
}

- Capt. Michael · Answer 4

除了使用 StringBuilder/StringBuffer 来反转字符串并检查它是否仍等于原始字符串的方法之外，这里有一种使用 for 循环的方法。

private boolean isPalindrome(String word) {
    if (word == null || word.isEmpty()) {
        return false;
    }

    int length = word.length();
    int middleIndex = length / 2;

    for (int index = 0; index < middleIndex; index++) {
        if (word.charAt(index) != word.charAt(length - index - 1)) {
            return false;
        }
    }

    return true;
}

- Nitesh · Answer 5

import java.util.Scanner;


public class Palindrom {

    public static void main(String []args)
    {
        Scanner in = new Scanner(System.in);
        String str= in.nextLine();
        int x= str.length();

        if(x%2!=0)
        {
            for(int i=0;i<x/2;i++)
            {

                if(str.charAt(i)==str.charAt(x-1-i))
                {
                    continue;
                }
                else 
                {
                    System.out.println("String is not a palindrom");
                    break;
                }
            }
        }
        else
        {
            for(int i=0;i<=x/2;i++)
            {
                if(str.charAt(i)==str.charAt(x-1-i))
                {
                    continue;
                }
                else 
                {
                    System.out.println("String is not a palindrom");
                    break;
                }

            }
        }
    }

}

- Md. Nasir Uddin · Answer 6

在这里，您可以动态地检查回文数字或字符串

import java.util.Scanner;

public class Checkpalindrome {
 public static void main(String args[]) {
  String original, reverse = "";
  Scanner in = new Scanner(System.in);
  System.out.println("Enter How Many number of Input you want : ");
  int numOfInt = in.nextInt();
  original = in.nextLine();
do {
  if (numOfInt == 0) {
    System.out.println("Your Input Conplete");
   } 
  else {
    System.out.println("Enter a string to check palindrome");
    original = in.nextLine();

    StringBuffer buffer = new StringBuffer(original);
    reverse = buffer.reverse().toString();

  if (original.equalsIgnoreCase(reverse)) {
    System.out.println("The entered string is Palindrome:"+reverse);
   } 
  else {
    System.out.println("The entered string is not Palindrome:"+reverse);
    }
 }
   numOfInt--;
    } while (numOfInt >= 0);
}
}

- huseyin · Answer 7

考虑单词中不包含字母

public static boolean palindromeWords(String s ){

        int left=0;
        int right=s.length()-1;

        while(left<=right){

            while(left<right && !Character.isLetter(s.charAt(left))){
                left++;
            }
            while(right>0 && !Character.isLetter(s.charAt(right))){
                right--;
            }

            if((s.charAt(left++))!=(s.charAt(right--))){
                return false;
            }
        }
        return true;
    }

———

@Test
public void testPalindromeWords(){
    assertTrue(StringExercise.palindromeWords("ece"));
    assertTrue(StringExercise.palindromeWords("kavak"));
    assertFalse(StringExercise.palindromeWords("kavakdf"));
    assertTrue(StringExercise.palindromeWords("akka"));
    assertTrue(StringExercise.palindromeWords("??e@@c_--e"));
}

- john Smith · Answer 8

在我看来，递归方式是最简单和最清晰的。

public static boolean isPal(String s)
{   
    if(s.length() == 0 || s.length() == 1)
        return true; 
    if(s.charAt(0) == s.charAt(s.length()-1))
       return isPal(s.substring(1, s.length()-1));                
   return false;
}

- juanmf · Answer 9

在这里，检查字符串中最大回文，始终从第一个字符开始。

public static String largestPalindromeInString(String in) {
    int right = in.length() - 1;
    int left = 0;
    char[] word = in.toCharArray();
    while (right > left && word[right] != word[left]) {
        right--;
    }
    int lenght = right + 1;
    while (right > left && word[right] == word[left]) {

        left++;
        right--;

    }
    if (0 >= right - left) {
        return new String(Arrays.copyOf(word, lenght ));
    } else {
        return largestPalindromeInString(
                new String(Arrays.copyOf(word, in.length() - 1)));
    }
}

- ch Noman · Answer 10

public class palindrome {

    public static void main(String[] args) {

        Scanner scanner=new Scanner(System.in);
        System.out.println("Enter the line you want to check palindrome:");
        String s= scanner.nextLine();

        StringTokenizer separate = new StringTokenizer(s, " ");
        System.out.println("\nPalindrome Words are: ");
        while(separate.hasMoreTokens()) {
            String word = separate.nextToken();
            String reversedWord = new StringBuilder(word).reverse().toString().toLowerCase();
            if ((word.toLowerCase().equals(reversedWord))){
                System.out.println(word);
            }
        }
    }
}