时间复杂度为O(n^2)的最长回文子串方法

最长回文子串普通循环解法代码：

class Solution {
    public String longestPalindrome(String s) {
        int n = s.length();
        int maxLen = 0;
        String longestPal = ""; // 用于存储最长回文子串
        for(int i = 0; i < n; i++) {
            for(int j = i; j < n; j++) {
                if(isTrue(s.substring(i, j + 1))) {
                    int len = j - i + 1;
                    if(len > maxLen) {
                        maxLen = len;
                        longestPal = s.substring(i, j + 1);
                    }
                }
            }   
        }
        return longestPal; // 返回最长回文子串
    }

    public boolean isTrue(String s) {
        int n = s.length() - 1;
        int i = 0;
        while(i < n) {
            if(s.charAt(i) != s.charAt(n)) // 使用 charAt() 方法
                return false;
            i++;
            n--;
        }
        return true;
    }
}

超出时间限制可能是因为代码时间复杂度过高。使用实现的时间复杂度是 (O(n^3))，因为有两个嵌套的循环和一个检查回文的子字符串的过程。可以通过改进算法来解决这个问题。

一个更高效的方法是使用“中心扩展法”来查找最长回文子串，其时间复杂度为 (O(n^2))。具体做法是，从每个字符和每两个字符之间扩展回文中心，检查每个可能的回文子串。

以下是改进后的代码：

class Solution {
    public String longestPalindrome(String s) {
        if (s == null || s.length() == 0) return "";
        
        int start = 0, maxLen = 1;
        for (int i = 0; i < s.length(); i++) {
            // 检查以 i 为中心的回文
            int len1 = expandAroundCenter(s, i, i);
            // 检查以 i 和 i+1 为中心的回文
            int len2 = expandAroundCenter(s, i, i + 1);
            int len = Math.max(len1, len2);
            if (len > maxLen) {
                maxLen = len;
                start = i - (maxLen - 1) / 2;
            }
        }
        return s.substring(start, start + maxLen);
    }

    private int expandAroundCenter(String s, int left, int right) {
        while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
            left--;
            right++;
        }
        return right - left - 1;
    }
}

主要优化：

1. 中心扩展法：对于每个字符位置和每对相邻字符位置，扩展回文串，计算其长度。
2. 时间复杂度：改进后的方法时间复杂度为 (O(n^2))，并且空间复杂度为 (O(1))。

这样，代码应能在更短的时间内找到最长回文子串。