串的模式匹配——KMP算法

KMP算法听起来名字很高大上，实际上，他就是三个提出者的名字首字母。

这里主要是想手写一遍KMP算法，加深印象。

暴力匹配：

        暴力匹配就是将字符串和模式串中的字符一一匹配，如果在匹配过程中出现未匹配上的情况，就将字符串指针回退到这轮匹配的起始位置+1，模式串指针回退到第一个字符。

#include <iostream>
#include <string.h>
using namespace std;

// 暴力解法：字符串下标从0开始
int baoLi(string S, string T) {
    int i = 0, j = 0;
    int k = 0;                   // 这轮匹配的起始位置  

    while (i < S.length() && j < T.length()) {
        if (S[i] == S[j]) {
            i++;
            j++;
        } else {
            j = 0;
            k++;
            i = k;
        }
    }
    if (j >= T.length())
        return k;
    else
        return -1;
}

正式进入KMP算法：

        KMP算法在未匹配上时，不需要回退字符串指针，只需要回退模式串指针，且模式串指针不一定回退到第一个字符，这样就大大减少了重复匹配的次数。

        关键是求出 next数组，next数组记录了当这一轮出现未匹配的情况时，模式串指针回退到的位置。

        如，next[j]，就是当这一轮匹配过程中，当模式串中第 j 个字符未匹配上时，模式串指针需要回退到 next[j]位置。

1.求next数组

// KMP算法：求next数组
// 字符串和next数组 下标从1开始
void getNext(String T, int[] next) {
    int i = 1, j = 0;
    next[1] = 0;
    
    while (i <= T.length()) {
        if (j == 0 || T[i - 1] == T[j - 1]) {
            i++;
            j++;
            next[i] = j;
        } else {
            j = next[j];
        }
    }
}

2.KMP算法主体

// KMP算法：主体
// 字符串和next数组 下标从1开始
int KMP(string S, string T, int next[]) {
    getNext(T, next);
    int i = 1, j = 1;
    while (i <= S.length() && j <= T.length()) {
        if (j == 0 || S[i - 1] == T[j - 1]) {
            i++;
            j++;
        } else {
            j = next[j];
        }
    }
    if (j > T.length())
        return i - T.length();
    return -1;
}

3.KMP算法优化

        这里优化的next数组。

void get_nextval(string T, int nextval[]) {
    int i = 1, j = 0;
    nextval[1] = 0;
    
    while (i <= T.length()) {
        if (j == 0 || T[i - 1] == T[j - 1]) {
            i++;
            j++;
            if (T[i - 1] != T[j - 1])
                nextval[i] = j;
            else
                nextval[i] = nextval[j];
        } else {
            j = nextval[j];
        }
    }
}