KMP算法理解

KMP（Knuth-Morris-Pratt）算法是一种用于在字符串中查找子串的高效算法。它利用了已经匹配过的信息，避免了不必要的回溯，从而提高了字符串匹配的效率。

KMP算法的关键在于构建一个部分匹配表（也称为失配函数），用来指导匹配过程中的跳转。这个表记录了当出现不匹配时，模式串应该移动的位置。

好的，让我给你一个简单易懂的例子来解释KMP算法的基本思想。

假设我们要在字符串 "ABCDABD" 中查找子串 "ABD" 的位置。我们可以使用暴力匹配算法来实现，即从字符串的第一个位置开始，依次比较子串和字符串中的字符，直到找到匹配的位置或者匹配失败。

下面是暴力匹配算法的匹配过程：

```
A B C D A B D
  A B D
  ^
```

从字符串的第一个位置开始匹配。当匹配到 "A" 和 "A" 时，它们匹配成功，继续匹配下一个字符。

```
A B C D A B D
    A B D
    ^
```

接着，当匹配到 "B" 和 "B" 时，它们匹配成功，继续匹配下一个字符。

```
A B C D A B D
      A B D
      ^
```

然后，当匹配到 "D" 和 "D" 时，它们匹配成功，匹配完成，返回匹配的起始位置，即索引 4。

暴力匹配算法的时间复杂度为 $O(mn)$，其中 $m$ 是子串的长度，$n$ 是字符串的长度。当子串和字符串的长度都很大时，暴力匹配算法的性能会很低。

KMP算法通过预处理子串的部分匹配表来避免不必要的比较，提高了匹配的效率。下面是KMP算法的匹配过程：

首先，我们需要构建子串 "ABD" 的部分匹配表。部分匹配表如下：

\[
\begin{array}{c|c|c|c}
\text{字符} & A & B & D \\
\hline
\text{部分匹配值} & 0 & 0 & 0 \\
\end{array}
\]

然后，我们可以使用KMP算法在字符串中查找子串。匹配过程如下：

```
A B C D A B D
            ^
```

从字符串的第一个位置开始匹配。当匹配到 "A" 和 "A" 时，它们匹配成功，继续匹配下一个字符。

```
A B C D A B D
              ^
```

接着，当匹配到 "B" 和 "B" 时，它们匹配成功，继续匹配下一个字符。

```
A B C D A B D
                ^
```

然后，当匹配到 "D" 和 "D" 时，它们匹配成功，匹配完成，返回匹配的起始位置，即索引 4。

在这个例子中，KMP算法和暴力匹配算法的匹配结果是相同的。但是，当子串和字符串的长度都很大时，KMP算法的性能会比暴力匹配算法更好。

这就是KMP算法的基本思想和匹配过程，下面是用Java实现KMP算法的代码：

public class KMP {

    public static int kmp(String text, String pattern) {
        int[] prefixTable = computePrefixTable(pattern);
        
        int i = 0; // 指向文本字符串的指针
        int j = 0; // 指向模式字符串的指针
        
        while (i < text.length()) {
            if (text.charAt(i) == pattern.charAt(j)) {
                // 匹配成功
                if (j == pattern.length() - 1) {
                    return i - j; // 返回匹配的起始位置
                }
                i++;
                j++;
            } else {
                // 匹配失败，根据前缀表移动模式字符串的指针
                if (j != 0) {
                    j = prefixTable[j - 1];
                } else {
                    i++;
                }
            }
        }
        
        return -1; // 未找到匹配的子串
    }

    private static int[] computePrefixTable(String pattern) {
        int[] prefixTable = new int[pattern.length()];
        
        int i = 1;
        int j = 0;
        
        while (i < pattern.length()) {
            if (pattern.charAt(i) == pattern.charAt(j)) {
                prefixTable[i] = j + 1;
                i++;
                j++;
            } else {
                if (j != 0) {
                    j = prefixTable[j - 1];
                } else {
                    prefixTable[i] = 0;
                    i++;
                }
            }
        }
        
        return prefixTable;
    }

    public static void main(String[] args) {
        String text = "ababcabcabababd";
        String pattern = "abcabd";
        
        int index = kmp(text, pattern);
        if (index != -1) {
            System.out.println("Pattern found at index " + index);
        } else {
            System.out.println("Pattern not found");
        }
    }
}
 

这段代码实现了KMP算法的核心逻辑。其中的kmp方法用于在文本字符串中找到模式字符串的匹配位置。computePrefixTable方法用于计算模式字符串的前缀表，用于在匹配失败时移动模式字符串的指针。在main方法中，我们使用了示例文本字符串和模式字符串进行测试，并输出匹配的起始位置。