递归理解java中的compareto（）方法

Question

我遇到了麻省理工学院关于递归的讲座，他们用递归检查回文，在那里他们用逻辑检查回文，比较第一个字母和最后一个字母等等。。 我的想法如下

只是一个伪代码：

    String original="abba";

    String reverse = "";
    for(int i=original.length()-1;i>=0;i--)
    {
        reverse+=new String(original.substring(i,i+1));
    }
    if(original.equals(reverse))
        System.out.println("palindrome");
    else
        System.out.println("not palindrome");

我有两个疑问

• 在时间复杂度方面，这种逻辑比递归或传统逻辑好吗
• compareTo()方法如何检查字符串是否相等？它比较字节码还是什么

Answer 1

您应该使用equals，而不是compareTo，因为compareTo返回的是int，而不是if条件所期望的布尔值。或者，您可以选中^{，这意味着字符串相等

至于compareTo是如何工作的，它会比较具有相同索引的每对字符，并返回第一对不相等字符之间的差异。如果全部相等，则返回0

Answer 2

Is this logic better than recursion or conventional logic in terms of time complexity?

假设您使用以下递归方法

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

时间复杂度：O(n)

等于：

public boolean equals(Object paramObject)
  {
    if (this == paramObject) {
      return true;
    }
    if ((paramObject instanceof String))
    {
      String str = (String)paramObject;
      int i = this.value.length;
      if (i == str.value.length)
      {
        char[] arrayOfChar1 = this.value;
        char[] arrayOfChar2 = str.value;
        for (int j = 0; i-- != 0; j++) {
          if (arrayOfChar1[j] != arrayOfChar2[j]) {
            return false;
          }
        }
        return true;
      }
    }
    return false;
  }

你的程序的复杂性是：O（n）+O（n）=O（n）

---

How does compareTo() method checks if strings are equal? DOes it compare bytecode or something?

compareTo:如果两个字符串相同，则返回0，否则返回第一个不匹配字符的差分、整数差分（即Unicode值的差分）

它通过比较两个字符串相同位置的字符来实现

  public int compareTo(String paramString)
  {
    int i = this.value.length;
    int j = paramString.value.length;
    int k = Math.min(i, j);
    char[] arrayOfChar1 = this.value;
    char[] arrayOfChar2 = paramString.value;
    for (int m = 0; m < k; m++)
    {
      int n = arrayOfChar1[m];
      int i1 = arrayOfChar2[m];
      if (n != i1) {
        return n - i1;
      }
    }
    return i - j;
  }

Answer 3

CompareTo将在字符串中的每个字符上循环。如果字符较大/较小（基于字母顺序），它将返回一个正数/负数

因此，当string1.compareTo(reverseString)==0时，这两个字符串是相同的。（没有一个字母比另一个字符串中的字母小/大）

因为您没有提供递归实现，所以很难说性能特征