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

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

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

- user2039532 · Answer 1

public class palindrome {
public static void main(String[] args) {
    StringBuffer strBuf1 = new StringBuffer("malayalam");
    StringBuffer strBuf2 = new StringBuffer("malayalam");
    strBuf2.reverse();


    System.out.println(strBuf2);
    System.out.println((strBuf1.toString()).equals(strBuf2.toString()));
    if ((strBuf1.toString()).equals(strBuf2.toString()))
        System.out.println("palindrome");
    else
        System.out.println("not a palindrome");
}

}

- gogobebe2 · Answer 2

我是Java的新手，我将接受您的问题作为提高知识的挑战。

import java.util.ArrayList;
import java.util.List;

public class PalindromeRecursiveBoolean {

    public static boolean isPalindrome(String str) {

        str = str.toUpperCase();
        char[] strChars = str.toCharArray();

        List<Character> word = new ArrayList<>();
        for (char c : strChars) {
            word.add(c);
        }

        while (true) {
            if ((word.size() == 1) || (word.size() == 0)) {
                return true;
            }
            if (word.get(0) == word.get(word.size() - 1)) {
                word.remove(0);
                word.remove(word.size() - 1);
            } else {
                return false;

            }

        }
    }
}

如果字符串由没有字母或只有一个字母组成，则它是回文。
否则，比较字符串的第一个和最后一个字母。
- 如果第一个和最后一个字母不同，则该字符串不是回文
- 否则，第一个和最后一个字母相同。从字符串中删除它们，确定剩余的字符串是否是回文。将此较小字符串的答案作为原始字符串的答案，然后重复从1开始。

- Madura Harshana · Answer 3

另一种方法是使用字符数组。

public class Palindrome {

public static void main(String[] args) {
    String str = "madam";
    if(isPalindrome(str)) {
        System.out.println("Palindrome");
    } else {
        System.out.println("Not a Palindrome");
    }
}

private static boolean isPalindrome(String str) {
    // Convert String to char array
    char[] charArray = str.toCharArray();  
    for(int i=0; i < str.length(); i++) {
        if(charArray[i] != charArray[(str.length()-1) - i]) {
            return false;
        }
    }
    return true;
}

}

- Amandeep Dhanjal · Answer 4

public boolean isPalindrome(String abc){
    if(abc != null && abc.length() > 0){
        char[] arr = abc.toCharArray();
        for (int i = 0; i < arr.length/2; i++) {
            if(arr[i] != arr[arr.length - 1 - i]){
                return false;
            }
        }
        return true;
    }
    return false;
}

- ARAVIN · Answer 5

试一试：

import java.util.*;
    public class str {

        public static void main(String args[])
        {
          Scanner in=new Scanner(System.in);
          System.out.println("ENTER YOUR STRING: ");
          String a=in.nextLine();
          System.out.println("GIVEN STRING IS: "+a);
          StringBuffer str=new StringBuffer(a);
          StringBuffer str2=new StringBuffer(str.reverse());
          String s2=new String(str2);
          System.out.println("THE REVERSED STRING IS: "+str2);
            if(a.equals(s2))    
                System.out.println("ITS A PALINDROME");
            else
                System.out.println("ITS NOT A PALINDROME");
            }
    }

- Fernando Pelliccioni · Answer 6

这是@Greg答案的分析：componentsprogramming.com/palindromes。

旁注：但是，对我来说以一种通用的方式完成它非常重要。要求是序列是双向可迭代的，并且序列的元素可以使用相等性进行比较。我不知道如何在Java中做到这一点，但是这里有一个C++版本，我不知道为双向序列做得更好的方法。

template <BidirectionalIterator I> 
    requires( EqualityComparable< ValueType<I> > ) 
bool palindrome( I first, I last ) 
{ 
    I m = middle(first, last); 
    auto rfirst = boost::make_reverse_iterator(last); 
    return std::equal(first, m, rfirst); 
}

复杂度：线性时间，

如果 I 是 RandomAccessIterator: floor(n/2) 次比较和 floor(n/2)*2 次迭代
如果 I 是 BidirectionalIterator: floor(n/2) 次比较和 floor(n/2)*2 次迭代加上 (3/2)*n 次迭代以找到中间位置（middle function）
存储：O(1)
没有动态分配的内存

- Pratik Patil · Answer 7

此实现适用于数字和字符串。

由于我们不需要写入任何内容，所以无需将字符串转换为字符数组。

public static boolean isPalindrome(Object obj)
{
    String s = String.valueOf(obj);

    for(int left=0, right=s.length()-1; left < right; left++,right--)
    {
        if(s.charAt(left++) != s.charAt(right--))
            return false;
    }
    return true;
}

- bluesony · Answer 8

为什么不直接这样写：

：

boolean isPalindrom(String s) {
        char[] myChars = s.toCharArray();
        for (int i = 0; i < myChars.length/2; i++) {
            if (myChars[i] != myChars[myChars.length - 1 - i]) {
                return false;
            }
        }
        return true;
}

- capt.swag · Answer 9

最近我编写了一个回文程序，它不使用StringBuilder。虽然晚了一些，但这可能对一些人有用。

public boolean isPalindrome(String value) {
    boolean isPalindrome = true;
    for (int i = 0 , j = value.length() - 1 ; i < j ; i ++ , j --) {
        if (value.charAt(i) != value.charAt(j)) {
            isPalindrome = false;
        }
    }
    return isPalindrome;
}

- aayushi · Answer 10

使用堆栈，可以像这样完成。

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
import java.util.*;

public class Solution {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str=in.nextLine();
        str.replaceAll("\\s+","");
        //System.out.println(str);
        Stack<String> stack=new Stack<String>();
        stack.push(str);
        String str_rev=stack.pop();
        if(str.equals(str_rev)){
            System.out.println("Palindrome"); 
        }else{
             System.out.println("Not Palindrome");
        }
    }
}