【408考点之数据结构】串的模式匹配算法

串的模式匹配算法

在计算机科学中，串的模式匹配是一个重要的问题，涉及在一个主串（Text）中寻找一个子串（Pattern）的出现位置。模式匹配算法是解决这一问题的核心，主要目标是提高匹配效率。以下介绍几种常见的模式匹配算法及其实现。

1. 朴素匹配算法（Naive Matching Algorithm）

朴素匹配算法是最基本的字符串匹配算法，依次将模式串与主串的各个子串进行比较，直到找到匹配的子串或遍历完整个主串。其时间复杂度为O((n-m+1)*m)，其中n为主串长度，m为模式串长度。

算法思路：

1. 从主串的第一个字符开始，将模式串与主串的子串进行逐个字符比较。
2. 如果匹配成功，则返回匹配的位置。
3. 如果匹配失败，则将模式串右移一位，继续比较。
4. 重复上述过程，直到找到匹配或遍历完整个主串。

代码实现：

#include <stdio.h>
#include <string.h>

// 朴素匹配算法
int naiveMatch(char* text, char* pattern) {
    int n = strlen(text);
    int m = strlen(pattern);
    for (int i = 0; i <= n - m; i++) {
        int j = 0;
        while (j < m && text[i + j] == pattern[j]) {
            j++;
        }
        if (j == m) {
            return i; // 匹配成功，返回匹配位置
        }
    }
    return -1; // 匹配失败
}

int main() {
    char text[] = "hello world";
    char pattern[] = "world";
    int pos = naiveMatch(text, pattern);
    if (pos != -1) {
        printf("Pattern found at position %d\n", pos);
    } else {
        printf("Pattern not found\n");
    }
    return 0;
}

2. KMP算法（Knuth-Morris-Pratt Algorithm）

KMP算法通过预处理模式串，构建部分匹配表（Partial Match Table），避免了重复比较，显著提高了匹配效率。其时间复杂度为O(n + m)。

算法思路：

1. 预处理模式串，构建部分匹配表（next数组），记录模式串中各个前缀的最长可匹配后缀长度。
2. 利用部分匹配表，在匹配过程中遇到不匹配字符时，模式串右移位数为当前字符的部分匹配值，避免了重复比较。

代码实现：

#include <stdio.h>
#include <string.h>

// 计算部分匹配表（next数组）
void computeNext(char* pattern, int* next) {
    int m = strlen(pattern);
    next[0] = 0;
    int j = 0;
    for (int i = 1; i < m; i++) {
        while (j > 0 && pattern[i] != pattern[j]) {
            j = next[j - 1];
        }
        if (pattern[i] == pattern[j]) {
            j++;
        }
        next[i] = j;
    }
}

// KMP匹配算法
int kmpMatch(char* text, char* pattern) {
    int n = strlen(text);
    int m = strlen(pattern);
    int next[m];
    computeNext(pattern, next);

    int j = 0;
    for (int i = 0; i < n; i++) {
        while (j > 0 && text[i] != pattern[j]) {
            j = next[j - 1];
        }
        if (text[i] == pattern[j]) {
            j++;
        }
        if (j == m) {
            return i - m + 1; // 匹配成功，返回匹配位置
        }
    }
    return -1; // 匹配失败
}

int main() {
    char text[] = "hello world";
    char pattern[] = "world";
    int pos = kmpMatch(text, pattern);
    if (pos != -1) {
        printf("Pattern found at position %d\n", pos);
    } else {
        printf("Pattern not found\n");
    }
    return 0;
}

3. BM算法（Boyer-Moore Algorithm）

BM算法通过模式串的预处理，在匹配过程中利用坏字符规则（Bad Character Rule）和好后缀规则（Good Suffix Rule）实现大跨度的跳跃，从而提高匹配效率。其时间复杂度为O(n)。

算法思路：

1. 预处理模式串，构建坏字符规则表和好后缀规则表。
2. 从模式串的最后一个字符开始进行匹配，利用规则表决定模式串的移动位数。

代码实现：

#include <stdio.h>
#include <string.h>

#define ALPHABET_SIZE 256

// 计算坏字符表
void computeBadChar(char* pattern, int m, int badChar[ALPHABET_SIZE]) {
    for (int i = 0; i < ALPHABET_SIZE; i++) {
        badChar[i] = -1;
    }
    for (int i = 0; i < m; i++) {
        badChar[(int)pattern[i]] = i;
    }
}

// BM匹配算法
int bmMatch(char* text, char* pattern) {
    int n = strlen(text);
    int m = strlen(pattern);
    int badChar[ALPHABET_SIZE];
    computeBadChar(pattern, m, badChar);

    int s = 0; // 模式串相对主串的偏移量
    while (s <= n - m) {
        int j = m - 1;
        while (j >= 0 && pattern[j] == text[s + j]) {
            j--;
        }
        if (j < 0) {
            return s; // 匹配成功，返回匹配位置
        } else {
            s += (j - badChar[(int)text[s + j]] > 1) ? j - badChar[(int)text[s + j]] : 1;
        }
    }
    return -1; // 匹配失败
}

int main() {
    char text[] = "hello world";
    char pattern[] = "world";
    int pos = bmMatch(text, pattern);
    if (pos != -1) {
        printf("Pattern found at position %d\n", pos);
    } else {
        printf("Pattern not found\n");
    }
    return 0;
}

模式匹配算法在字符串处理和文本编辑中具有重要应用。朴素匹配算法简单易懂，但效率较低。KMP算法通过预处理模式串，避免重复比较，大幅提高了效率。BM算法则利用坏字符规则和好后缀规则，实现大跨度跳跃匹配，是效率较高的模式匹配算法。在实际应用中，根据需求选择合适的算法，可以显著提升程序的性能和处理速度。