字符串匹配问题———BF算法与KMP算法

一、字符串匹配问题

给定一个母串和一个子串，在母串中找出子串出现的第一个位置 (字符串下标从0开始)。如果不存在，则返回  -1。

二、BF算法与KMP算法

1.BF算法

BF算法是一种朴素的字符串匹配算法，也称为暴力算法。它的思想是从文本的每个位置开始，逐个字符地和模式串进行比较，直到找到匹配或者遍历完整个文本。如果文本长度为n，模式串长度为m，那么BF算法的时间复杂度为O(n * m)。由于需要逐个字符地比较，所以在最坏情况下，算法的时间复杂度为O(n * m)。
 

// Brute-Force算法
int BF(string text, string pattern) {
    int n = text.length();
    int m = pattern.length();
    for (int i = 0; i <= n - m; i++) {
        int j;
        for (j = 0; j < m; j++) {
            if (text[i + j] != pattern[j])
                break;
        }
        if (j == m)
            return i;  // 匹配成功，返回匹配的起始位置
    }
    return -1;  // 匹配失败，返回-1
}

2.KMP算法

KMP算法是一种改进的字符串匹配算法，通过预处理模式串，利用已经匹配过的信息，跳过无需再次比较的字符，从而减少比较次数，提高匹配效率。KMP算法的核心是构建一个部分匹配表（Partial Match Table），用于记录模式串中的每个位置之前的字符串的最长公共前后缀长度。通过部分匹配表，KMP算法可以在匹配过程中根据已经匹配的信息进行跳跃，减少比较次数，从而将时间复杂度降低到O(n + m)。
 

// KMP算法
void buildLPS(string pattern, int* lps) {
    int m = pattern.length();
    lps[0] = 0;
    int len = 0;
    int i = 1;
    while (i < m) {
        if (pattern[i] == pattern[len]) {
            len++;
            lps[i] = len;
            i++;
        }
        else {
            if (len != 0)
                len = lps[len - 1];
            else {
                lps[i] = 0;
                i++;
            }
        }
    }
}
int KMP(string text, string pattern) {
    int n = text.length();
    int m = pattern.length();
    int* lps = new int[m];
    buildLPS(pattern, lps);
    int i = 0, j = 0;
    while (i < n) {
        if (text[i] == pattern[j]) {
            i++;
            j++;
        }
        if (j == m) {
            delete[] lps;
            return i - j;  // 匹配成功，返回匹配的起始位置
        }
        if (i < n && text[i] != pattern[j]) {
            if (j != 0)
                j = lps[j - 1];
            else
                i++;
        }
    }
    delete[] lps;
    return -1;  // 匹配失败，返回-1
}

三、代码实现

#include <iostream>
#include <string>
using namespace std;
// Brute-Force算法
int BF(string text, string pattern) {
    int n = text.length();
    int m = pattern.length();
    for (int i = 0; i <= n - m; i++) {
        int j;
        for (j = 0; j < m; j++) {
            if (text[i + j] != pattern[j])
                break;
        }
        if (j == m)
            return i;  // 匹配成功，返回匹配的起始位置
    }
    return -1;  // 匹配失败，返回-1
}
// KMP算法
void buildLPS(string pattern, int* lps) {
    int m = pattern.length();
    lps[0] = 0;
    int len = 0;
    int i = 1;
    while (i < m) {
        if (pattern[i] == pattern[len]) {
            len++;
            lps[i] = len;
            i++;
        }
        else {
            if (len != 0)
                len = lps[len - 1];
            else {
                lps[i] = 0;
                i++;
            }
        }
    }
}
int KMP(string text, string pattern) {
    int n = text.length();
    int m = pattern.length();
    int* lps = new int[m];
    buildLPS(pattern, lps);
    int i = 0, j = 0;
    while (i < n) {
        if (text[i] == pattern[j]) {
            i++;
            j++;
        }
        if (j == m) {
            delete[] lps;
            return i - j;  // 匹配成功，返回匹配的起始位置
        }
        if (i < n && text[i] != pattern[j]) {
            if (j != 0)
                j = lps[j - 1];
            else
                i++;
        }
    }
    delete[] lps;
    return -1;  // 匹配失败，返回-1
}

int main() {
    string text = "ABCeABeCDABABeCDABCD";
    string pattern = "ABCD";

    // 使用BF算法进行字符串匹配
    int bf_index = BF(text, pattern);
    if (bf_index != -1)
        cout << "BF算法：匹配成功，起始位置为 " << bf_index << endl;
    else
        cout << "BF算法：匹配失败" << endl;

    // 使用KMP算法进行字符串匹配
    int kmp_index = KMP(text, pattern);
    if (kmp_index != -1)
        cout << "KMP算法：匹配成功，起始位置为 " << kmp_index << endl;
    else
        cout << "KMP算法：匹配失败" << endl;

    return 0;
}