Java:实现找出字符串中最长的回文子字符串算法（附带源码）

最新推荐文章于 2025-12-01 18:34:47 发布

原创最新推荐文章于 2025-12-01 18:34:47 发布 · 1k 阅读

20 ·

CC 4.0 BY-SA版权

文章标签：

#java #算法 #开发语言

Java算法完整教程专栏收录该内容

703 篇文章

订阅专栏

1. 项目背景详细介绍

在文本处理、自然语言处理以及字符串算法研究领域，回文子串问题具有重要意义。回文（Palindrome）指的是正读和反读都相同的字符串片段。在实际应用中，回文检测和提取常用于生物信息学中 DNA 序列的对称区域识别、文本纠错中对称模式匹配、以及面试算法题考察字符串动态规划或中心扩展技术等。最长回文子串（Longest Palindromic Substring）问题为经典算法问题之一：给定一个字符串，找出其中最长的回文子串并返回。

该问题对于初学者而言，能够帮助其加深对字符串操作、双指针技巧、中心扩展法、动态规划、Manacher 算法（线性时间解决回文问题）等多种解法的理解，也为面试中常见的高频题型。通过本项目，读者将全面掌握 Java 语言下回文子串检测与搜索的多种思路与实现，涵盖时间复杂度从 O(n²) 到 O(n) 的优化过程，为实际开发或算法面试打下坚实基础。

2. 项目需求详细介绍

功能需求
- 输入任意字符串 s，支持空串、单字符、包含空格及特殊字符的任意可打印字符序列。
- 实现方法 public String longestPalindrome(String s)，返回字符串 s 中最长的回文子串。
- 提供示例演示：多种测试用例，包括所有字符相同、无重复字符、偶数长度回文、奇数长度回文、混合型等。
非功能需求
- 使用 Java 8 及以上版本编写，代码风格符合 Oracle Java 编程规范。
- 注释详尽，变量命名规范，易于维护与阅读。
- 提供三种解法：
  1. 暴力枚举法（时间复杂度 O(n³)，仅作演示）。
  2. 中心扩展法（时间复杂度 O(n²)、空间复杂度 O(1)）。
  3. Manacher 算法（时间复杂度 O(n)、空间复杂度 O(n)）。
- 采用单元测试框架 JUnit（可选）进行基本测试验证，虽然示例中不依赖外部库。
- 算法设计需考虑边界条件：空串、全部相同字符及超长字符串。
部署与运行
- 项目无需额外依赖，在标准 JDK 环境下通过命令行或 IDE 直接编译执行。
- 提供 Main.java 入口类，接受命令行参数或在代码中硬编码测试用例并打印结果。

3. 相关技术详细介绍

字符串基本操作
- charAt(int index)、substring(int beginIndex, int endIndex)、toCharArray() 等方法的使用与性能开销分析。
- StringBuilder、StringBuffer 的区别，以及它们在高频子串拼接场景下的适用性。
暴力枚举解法
- 两层循环枚举起始和结束索引，内层通过双指针判断子串是否回文；
- 时间复杂度分析：O(n³)，适用于小规模字符串，主要用于对比和理解。
中心扩展法
- 回文对称性：回文字符串以其中心为对称轴；遍历每个可能的中心（包括字符与字符之间的位置），向两侧扩展。
- 时间复杂度 O(n²)，空间复杂度 O(1)，实现简单直观。
Manacher 算法
- 在线性时间内解决最长回文子串问题，通过在原字符串两字符间插入特殊分隔符（如 #），将奇偶回文统一为奇数长度；
- 利用对称性质维护当前最大回文右边界 R 和其中心 C，以及动态记录每个位置的“回文半径”数组 P[]；
- 时间复杂度 O(n)、空间复杂度 O(n)，适用于超长字符串处理。
复杂度与性能对比
- 针对不同长度的输入测试，分析三种算法在 Java 中的实际运行时间与内存消耗趋势；
- 通过 JMH（Java Microbenchmark Harness）进行基准测试，可扩展，但示例中不引入。
JUnit 单元测试（可选）
- 基础测试用例覆盖：空串、单字符、均相同字符、无回文子串（即任意字符均回文长度为1）、偶数回文、奇数回文。
- 使用 @Test 注解和断言 assertEquals 验证 longestPalindrome 返回值正确性。

4. 实现思路详细介绍

4.1 暴力枚举法

双重循环枚举所有可能子串，外层枚举起始位置 i，内层枚举结束位置 j（i ≤ j）。
对每个子串调用 isPalindrome(s, i, j) 方法判断是否回文，若是且长度大于当前最大长度则记录该子串位置与长度。
最终利用记录的起始位置和长度返回最长回文子串。
时间复杂度 O(n³)，仅作为理解基础。

4.2 中心扩展法

回文字符串的中心可能是一个字符（奇数长度回文）或两字符之间（偶数长度回文）。
对每个位置 i：
- 以 i 为中心，调用 expandAroundCenter(s, i, i) 处理奇数长度；
- 以 i 与 i+1 为双中心，调用 expandAroundCenter(s, i, i+1) 处理偶数长度；
expandAroundCenter 方法从中心向两侧扩展：当左右指针未越界且字符相等时，继续扩展，并实时更新最长回文区域。
遍历所有中心后，返回最终最长回文子串。
时间复杂度 O(n²)、空间复杂度 O(1)。

4.3 Manacher 算法

对原字符串 s 插入分隔符，将其转换为新字符串 T，例如 s = "aba" 转为 T = "^#a#b#a#$"，在两端再添加不同的哨兵字符避免越界检查。
创建整型数组 P，长度与 T 相同，用于记录以每个位置为中心的回文半径。
定义当前回文中心 C 和其右边界 R，初始均为 0；
遍历 T 中每个位置 i：
- 计算其对称位置 mirror = 2*C - i；
- 如果 i < R，则 P[i] = min(R - i, P[mirror])；否则 P[i] = 0；
- 然后尝试从 i 向两侧扩展，使得 T[i + 1 + P[i]] == T[i - 1 - P[i]]，并增加 P[i]；
- 如果 i + P[i] > R，则更新 C = i，R = i + P[i]；
遍历结束后，在 P 数组中找到最大值 maxLen 及其对应中心 centerIndex，计算对应在原字符串中的起始位置 (centerIndex - 1 - maxLen) / 2，并返回长度为 maxLen 的子串。
时间复杂度 O(n)、空间复杂度 O(n)。

5. 完整实现代码

// 文件：Main.java
// 入口类，演示最长回文子串的三种算法
public class Main {
    public static void main(String[] args) {
        String[] tests = {
            "", 
            "a", 
            "babad", 
            "cbbd", 
            "aaaa", 
            "abacdfgdcaba", 
            "abacdfgdcabba", 
            "racecar", 
            "a man, a plan, a canal: panama"
        };

        // 遍历测试用例
        for (String s : tests) {
            System.out.println("输入: \"" + s + "\"");
            // 暴力枚举法
            System.out.println("暴力枚举法结果: " + LongestPalindrome.bruteForce(s));
            // 中心扩展法
            System.out.println("中心扩展法结果: " + LongestPalindrome.centerExpand(s));
            // Manacher 算法
            System.out.println("Manacher 算法结果: " + LongestPalindrome.manacher(s));
            System.out.println("--------------------------------------------------");
        }
    }
}

// 文件：LongestPalindrome.java
// 包含三种最长回文子串实现方法
public class LongestPalindrome {

    /**
     * 方法一：暴力枚举法
     * 时间复杂度 O(n^3)，空间复杂度 O(1)
     * @param s 原始字符串
     * @return  最长回文子串
     */
    public static String bruteForce(String s) {
        if (s == null || s.length() < 1) return "";
        int start = 0, maxLen = 1;
        int n = s.length();
        for (int i = 0; i < n; i++) {
            for (int j = i; j < n; j++) {
                if (isPalindrome(s, i, j)) {
                    int len = j - i + 1;
                    if (len > maxLen) {
                        start = i;
                        maxLen = len;
                    }
                }
            }
        }
        return s.substring(start, start + maxLen);
    }

    /**
     * 判断子串 s[left..right] 是否为回文
     * @param s     原始字符串
     * @param left  子串左索引
     * @param right 子串右索引
     * @return      true 表示是回文，false 否则
     */
    private static boolean isPalindrome(String s, int left, int right) {
        while (left < right) {
            if (s.charAt(left++) != s.charAt(right--)) return false;
        }
        return true;
    }

    /**
     * 方法二：中心扩展法
     * 时间复杂度 O(n^2)，空间复杂度 O(1)
     * @param s 原始字符串
     * @return  最长回文子串
     */
    public static String centerExpand(String s) {
        if (s == null || s.length() < 1) return "";
        int start = 0, end = 0;
        for (int i = 0; i < s.length(); i++) {
            int len1 = expandAroundCenter(s, i, i);     // 奇数长度回文
            int len2 = expandAroundCenter(s, i, i + 1); // 偶数长度回文
            int len = Math.max(len1, len2);
            if (len > end - start + 1) {
                start = i - (len - 1) / 2;
                end = i + len / 2;
            }
        }
        return s.substring(start, end + 1);
    }

    /**
     * 从左右索引向两侧扩展，返回回文长度
     * @param s     原始字符串
     * @param left  左指针
     * @param right 右指针
     * @return      回文长度
     */
    private static 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;
    }

    /**
     * 方法三：Manacher 算法
     * 时间复杂度 O(n)，空间复杂度 O(n)
     * @param s 原始字符串
     * @return  最长回文子串
     */
    public static String manacher(String s) {
        if (s == null || s.length() < 1) return "";
        // 将 s 转换为带分隔符的字符串 T
        char[] t = preprocess(s);
        int n = t.length;
        int[] p = new int[n];     // 回文半径数组
        int center = 0, right = 0; // 当前回文中心及右边界
        int maxLen = 0, centerIndex = 0;

        for (int i = 1; i < n - 1; i++) {
            int mirror = 2 * center - i;
            if (i < right) {
                p[i] = Math.min(right - i, p[mirror]);
            } else {
                p[i] = 0;
            }
            // 向两侧扩展
            while (t[i + 1 + p[i]] == t[i - 1 - p[i]]) {
                p[i]++;
            }
            // 更新中心和右边界
            if (i + p[i] > right) {
                center = i;
                right = i + p[i];
            }
            // 记录最大回文长度和中心位置
            if (p[i] > maxLen) {
                maxLen = p[i];
                centerIndex = i;
            }
        }
        // 计算原始字符串中的起始位置
        int start = (centerIndex - 1 - maxLen) / 2;
        return s.substring(start, start + maxLen);
    }

    /**
     * 将原始字符串转换为带分隔符的字符数组
     * 例如 s = "aba"，转换后 T = "^#a#b#a#$"
     * @param s 原始字符串
     * @return  带分隔符的字符数组
     */
    private static char[] preprocess(String s) {
        int n = s.length();
        if (n == 0) return new char[] {'^', '$'};
        char[] t = new char[2 * n + 3];
        t[0] = '^';
        int idx = 1;
        for (char c : s.toCharArray()) {
            t[idx++] = '#';
            t[idx++] = c;
        }
        t[idx++] = '#';
        t[idx++] = '$';
        return t;
    }
}

6. 代码详细解读

Main.main：演示三种不同算法对多个测试用例进行最长回文子串的计算与结果输出。
LongestPalindrome.bruteForce：暴力枚举，双重循环加双指针判断回文，适合小规模输入。
LongestPalindrome.centerExpand：中心扩展，遍历每个可能中心，扩展得回文长度并更新最大区间。
LongestPalindrome.manacher：Manacher 算法，预处理分隔符数组，利用对称性质与动态维护的中心、右边界，实现线性时间解决回文问题。
辅助方法：isPalindrome 用于判断子串回文；expandAroundCenter 用于中心扩展；preprocess 用于生成 Manacher 分隔符数组。

7. 项目详细总结

本项目通过三种算法全面解析并实现了最长回文子串问题，分别涵盖了暴力枚举、中心扩展与 Manacher 算法三大经典思路。暴力解法虽然概念简单，但时间复杂度高；中心扩展法在 O(n²) 复杂度下具有较好可读性；Manacher 算法通过巧妙的预处理与对称性质，实现了 O(n) 线性时间的高效解决方案。通过对比三种方法的适用场景与性能差异，读者可根据实际需求灵活选择或优化。