Java 确定输入字符串是否为回文的有效方法

我最近编写了这个简短的方法来确定字符串是否是回文。我想知道我能做些什么来提高效率，当然我缺少了可以加速计算的简单内置函数

谢谢大家的帮助

boolean checkPalindrome(String inputString) {

    ArrayList<Character> arrFront = new ArrayList<Character>();
    ArrayList<Character> arrBack = new ArrayList<Character>();

    for(int i=0; i<inputString.length()-1; i++) {
        arrFront.add(inputString.charAt(i));
    }

    for(int i=inputString.length()-1; i>0; i--) {
        arrBack.add(inputString.charAt(i));
    }

    StringBuilder builder1 = new StringBuilder(arrFront.size());
    for (Character c : arrFront) {
        builder1.append(c);
    }
    String front = builder1.toString();

    StringBuilder builder2 = new StringBuilder(arrBack.size());
    for (Character c : arrBack) {
        builder2.append(c);
    }
    String back = builder2.toString();

    return(front.equals(back));
}

布尔检查回文（字符串输入字符串）{
ArrayList arrFront=新的ArrayList（）；
ArrayList arrBack=新的ArrayList（）；
对于（int i=0；i0；i--）{
add（inputString.charAt（i））；
}
StringBuilder builder1=新的StringBuilder（arrFront.size（））；
for（字符c:ARRRONT）{
构建者1.附加（c）；
}
String front=builder1.toString（）；
StringBuilder builder2=新的StringBuilder（arrBack.size（））；
for（字符c：arrBack）{
构建者2.附加（c）；
}
String back=builder2.toString（）；
返回（前面等于后面）；
}

就效率而言，并不总是关于内置函数和使用库（尽管在许多情况下它们是最佳选择）。但有时，像这样的简单循环可能是最简单有效的方法：

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

private boolean checkPalindrome（字符串inputString）{
对于（inti=0，j=inputString.length（）-1；i

可以参考@FernandoPelliccioni的文章。他对这个解决方案做了非常透彻的分析

对于简单的解决方案：

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

在效率方面：

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

公共静态布尔值isAlindrome（字符串str）{
int n=str.length（）；
对于（int i=0；i

这里有一个更简单的方法

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

public boolean checkPalindrome（String str）{
int len=inputString.length（）/2；
对于（int i=0；i

当str的长度为

N

时。时间复杂度为

O（N/2）

。 注意：str的长度为奇数时，不需要检查中间字符，因为它本身就是

比如说,

在

ssstsss

中，您不需要选中

t

由于

len

是int，它不能表示

小数部分。它会自动下降。
ssstsss
的
len
是
3
，因为它是
7/2=3.5
并且下降
0.5

即使它的长度是相等的，它也能工作。例如，
abccba
。长度为
6
。而
len
是
3
。当长度为偶数时，必须检查中间的两个字符，即<代码> cc。
 < P>我认为最简单的方法是使用默认<代码> StringBuilder < /代码>。br>
这个类得到了一个很好的函数，它可能是有用的。
它被称为
reverse（）
。它执行它所说的，它反转解析到
StringBuilder
中的字符串。有了它，就很容易检查给定的字符串是否等于反向字符串

例如，您可以执行以下操作：

public boolean isPallindrome(String input){
    StringBuilder reversed = new StringBuilder(input);
    reversed.reverse();
    /*
     * Just replace equals with equalsIgnoreCase
     * to ignore the case
     */
    return(reversed.toString().equalsIgnoreCase(input));
}

给定的代码只创建一个
StringBuilder
实例，并直接附加输入。
然后它反转
StringBuilder
，并检查输入是否等于反转的字符串。
你所说的
加速是什么意思？时间复杂度，还是代码更少？你是说像？请注意，这是较少的代码，但我正在投票结束这个问题，因为它属于代码审查SE。@Andreytukin是的，简单循环解决方案（
for（int I=0；I
）如果你关心efficiency@GBlodgett利用
str.length（）
也会加快速度！早点回来会有一段时间安全的。