字符串匹配算法深度解析：从暴力匹配到KMP优化

最新推荐文章于 2025-07-30 14:22:39 发布

原创最新推荐文章于 2025-07-30 14:22:39 发布 · 404 阅读

6 ·

CC 4.0 BY-SA版权

文章标签：

#算法

Java学习同时被 2 个专栏收录

27 篇文章

订阅专栏

数据结构

4 篇文章

订阅专栏

字符串匹配算法深度解析：从暴力匹配到KMP优化

1. 问题定义与背景

字符串匹配是计算机科学中的经典问题，定义为：

给定文本串 T（长度n）和模式串 P（长度m）
找出 P 在 T 中首次出现的起始位置
若不存在返回 -1

应用场景：
文本编辑器的查找功能、杀毒软件的特征码扫描、DNA序列匹配

2. 暴力匹配法（Brute-Force）

2.1 算法原理

通过滑动窗口逐个比较所有可能的子串

2.2 完整实现

 public int bruteForceSearch(String text, String pattern) {
       // 输入校验
       if (pattern == null || pattern.isEmpty()) 
           return 0;
       if (text == null || text.length() < pattern.length()) 
           return -1;

       final int n = text.length();
       final int m = pattern.length();
       
       // 主循环：文本串的每个起始位置
       for (int i = 0; i <= n - m; i++) {
           // 子串比较
           int j;
           for (j = 0; j < m; j++) {
               // 字符不匹配立即终止比较
               if (text.charAt(i + j) != pattern.charAt(j))
                   break;
           }
           // 完全匹配时返回位置
           if (j == m) 
               return i; 
       }
       return -1;  // 未找到
   }

2.3 复杂度分析

最坏时间复杂度：O((n-m+1)*m) ≈ O(n*m)
空间复杂度：O(1)
最佳情况：O(n)（首字符匹配失败时）

3. KMP算法深度解析

3.1 核心思想

利用「部分匹配表」避免回溯

关键概念：

部分匹配值（PMT）：最长公共前后缀长度
Next数组：PMT右移一位，next[j]表示P[0...j-1]的PMT

3.2 标准实现（含详细注释）

 public int kmpSearch(String text, String pattern) {
       // 边界条件处理
       if (pattern == null || pattern.isEmpty()) 
           return 0;
       if (text == null || text.length() < pattern.length()) 
           return -1;

       // 生成优化版next数组
       int[] next = buildNextArray(pattern);
       int i = 0, j = 0;
       final int n = text.length();
       final int m = pattern.length();

       // 主匹配循环
       while (i < n && j < m) {
           // j=-1表示需要重置匹配位置
           if (j == -1 || text.charAt(i) == pattern.charAt(j)) {
               i++;  // 文本指针前进
               j++;  // 模式指针前进
           } else {
               // 失配时跳转到next[j]位置
               j = next[j];  
           }
       }
       // 匹配成功返回起始位置
       return j == m ? i - j : -1;
   }

   // 构建优化版next数组
   private int[] buildNextArray(String pattern) {
       final int m = pattern.length();
       int[] next = new int[m];
       next[0] = -1;  // 初始化哨兵值
       int i = 0, j = -1;  // i:当前指针，j:前缀指针

       while (i < m - 1) {
           // 情况1：j=-1需要重置
           // 情况2：当前字符匹配成功
           if (j == -1 || pattern.charAt(i) == pattern.charAt(j)) {
               i++;
               j++;
               // 优化点：避免连续相同字符的重复比较
               if (pattern.charAt(i) != pattern.charAt(j)) {
                   next[i] = j;  // 正常赋值
               } else {
                   next[i] = next[j];  // 复用之前的结果
               }
           } else {
               // 失配时回溯前缀指针
               j = next[j];  
           }
       }
       return next;
   }