字符串的模式匹配——朴素模式及KMP算法

朴素模式匹配算法

代码实现

//朴素模式匹配算法
int strMatch(char s[], char p[]){   //s为主串，p为模式串
    int n = strlen(s), m = strlen(p);   //获取串的长度
    int i = 0;

    while(i <= n-m)
    {
        int j = 0;
        while ( s[i] == p[j] && j < m)
        {
            i ++;
            j ++;
        }
        if (j == m) return i-m; //匹配成功
        i = i - j + 1;  //主串回溯，从开始位置的下一位在开始
    }

    return -1;  //匹配失败
}

KMP算法

        KMP（Knuth-Morris-Pratt）算法是一种字符串匹配算法，用于在一个主串中查找一个模式串的出现位置。

        主要思想是减少不必要的比较次数，实现了时间复杂度为 O(m+n) 的字符串匹配算法，其中m是模式串的长度，n是主串的长度。

        KMP算法的核心是构建一个next数组，next [ i ] 表示当模式串匹配到第 i 个字符失配时，下一次该从模式串的第 next [ i ] 个字符开始匹配。

        常用的next数组的计算方法是通过递推计算，即对于当前的i，先找到其前一个字符的最长前缀后缀相同的长度，然后再考虑当前字符与其前缀的匹配情况，从而得到next [ i ]的值。

        下面是一个简单的用C++实现的KMP算法，其中包括next数组的计算和字符串匹配的过程。

代码实现

#include <iostream>
#include <string>
#include <vector>

using namespace std;

// 计算next数组
vector<int> getNext(string s) {
    int n = s.size();
    vector<int> next(n);
    for (int i = 1, j = 0; i < n; i++) {
        while (j && s[i] != s[j]) { // 如果s[i]和s[j]不相等，则根据next[j-1]找到前一个相同的位置
            j = next[j - 1];
        }
        if (s[i] == s[j]) { // 如果s[i]和s[j]相等，则next[i]为j+1
            j++;
        }
        next[i] = j;
    }
    return next; // 返回next数组
}

// KMP算法
int kmp(string s, string p) {
    int m = p.size(), n = s.size();
    vector<int> next = getNext(p); // 获取模式串的next数组
    for (int i = 0, j = 0; i < n; i++) {
        while (j && s[i] != p[j]) { // 如果s[i]和p[j]不相等，则根据next[j-1]找到前一个相同的位置
            j = next[j - 1];
        }
        if (s[i] == p[j]) { // 如果s[i]和p[j]相等，则继续匹配
            j++;
        }
        if (j == m) { // 如果匹配成功，返回匹配位置
            return i - m + 1;
        }
    }
    return -1; // 匹配失败，返回-1
}

int main() {
    string s = "ABCABCDABDABCDABDE"; // 主串
    string p = "ABCDABD"; // 模式串
    int pos = kmp(s, p); // 执行KMP算法
    cout << "pattern found at index " << pos << endl; // 输出匹配位置
    return 0;
}