串串的定义, 串的实现, 查找字符串, BF 算法, KMP 算法, next数组的创建, BM 算法,

定义

由一个或多个字符组成的有限序列

存储结构

定长顺序存储

#define Length 255

struct sstring {
    int length;
    char ch[Length];
};

此时使用结尾的 '\0' 或长度 length 标记结束位

块链存储

模式匹配

Brute-Force 算法（暴力算法）

令主串为 s, 需要匹配的字符串称为“模式” t

步骤

以主串 "BBC ABCDAB ABCDABCDABDE" 和模式 "ABCDABD" 为例, 下标从 1 开始

比较第一个字符

发现不匹配, 则模式后移一位继续匹配表现为 i(2) = i(1) - j(1) + 2, 即继续比较 s[2] 与 t[1]
s[2] 与 t[1] 也不匹配, 继续后移一位

以此类推, 到 D 发现不匹配

模式再后移一位, 模式从头开始重新匹配

表现为 i(6) = i(11) - j(7) + 2, 即继续比较 s[6] 与 t[1]

完全匹配后返回第一个匹配字符下标

表现为 index(12) = i(19) - t.length(7)

i=19 因为最后一次匹配(i=18)时相等, i++

代码实现

#include<stdio.h>

#define Length 255

struct sstring {
    int length;
    char ch[Length];
};

int find(sstring s, sstring t, int pos = 1) {
    int i = pos; // 默认从 1 开始查找
    int j = 1;
    
    int count = 0; // 比较次数
    
    // 下标不能超过两个字符串
    while (i <= s.length && j <= t.length) {
        count++;
        // 如果字符相等, 则继续下一个字符
        if (s.ch[i] == t.ch[j]) {
            i++;
            j++;
        }
        else {
            // 遇到不匹配的字符
            // 模式后移一位
            i = i - j + 2;

            // 模式重新从 1 开始匹配
            j = 1;
        }
    };
    
    printf("BF 算法比较次数: %d\n", count); // 26

    // j > t.length 说明模式完全匹配
    if (j > t.length) {
        // 返回模式第一个匹配的字符位置
        return i - t.length;
    }
    else {
        // 匹配不成功返回 -1
        return -1;
    }
}

int main() {
    // 前面一个 - 占位, 不起作用, 字符长度不包括 -
    sstring s = {23, "-BBC ABCDAB ABCDABDCABDE"}
        , t = {7, "-ABCDABD" };

    int index = find(s, t);

    printf("第一个匹配字符下标: %d", index);
}

复杂度分析

假设主串 s 长 n, 模式串 t 长 m

可能出现匹配的位置 $i\in[1, n - m + 1]$

最好的情况下, 如果在第 i 个位置匹配成功, 则前面 i-1 个位置都只比较一次就跳到下一个位置, 总共比较了 $(i-1) + m$ 次

平均比较次数为

\sum_{i=1}^{n-m+1}p(i-1+m)=\frac{1}{n-m+1}\sum_{i=1}^{n-m+1}(i-1+m)=\frac{1}{2}(m+n)

最坏的情况下, 如果第 i 个位置匹配成功, 则前面 i-1 个位置都比较 m 次(即每次都只是最后一个位置不一样), 总共比较了 $(i-1)×m+m=i×m$ 次

平均比较次数:

\sum_{i=1}^{n-m+1}p(i×m)=\frac{1}{n-m+1}\sum_{i=1}^{n-m+1}(i×m)=\frac{1}{2}m(n-m+2)

存在问题

前面都是匹配的, 突然遇到一个不匹配的, 如果再后移一位去比较, 之前匹配的字符就完全错位, 肯定是不会匹配的

KMP 算法

前缀和后缀

前缀: 除了最后一个字符外的字符子串集合

后缀: 除了第一个字符外的字符子串集合

以字符串 'ababa' 为例

a 没有前缀和后缀, 最大相等前后缀长度为 0
ab 的前缀为 {a}, 后缀为 {b}, 最大相等前后缀长度为 0
aba 的前缀为 {a, ab}, 后缀为 {a, ba}, 相等的前后缀为 {a}, 最大相等前后缀长度为 1
abab 的前缀为 {a, ab, aba}, 后缀为 {b, ab, bab}, 相等的前后缀为 {ab}, 因此最大相等前后缀长度为 2
ababa 的前缀为 {a, ab, aba, abab}, 后缀为 {a, ba, aba, baba}, 相等的前后缀为 {a, aba}, 最大相等前后缀长度为 3

PM 表

根据前后缀最大长度可以得出部分匹配表(PM 表)

最前面的 -1 是方便当 j=1 时出现不匹配时能够访问 PM(j-1), 为什么是 -1 与代码有关(后面说明)

这个表有什么用？

如上图, 当第 5 个不匹配时, 找到最后一个匹配字符(b)对应的部分匹配表值(2), 也就是说已经匹配了的字符串是 "abab", 其从左起, 有一个子字符串 "ab", 其在右边能找到一个一模一样的子字符串 "ab", 只需要将整体移动到后边, 就可以继续比较, 好处是 i 不需要“回退”了

ab 是最长相等前后缀, 所以两个 ab 之间不会存在更长的重复子字符串

那么这个移动距离是多少呢?

位移 = 已经匹配字符数 - 最后匹配字符的部分匹配表值

实际使用时, 不是把字符移动, 而是改变下标 j
即 j = j - ((j-1) - PM[j-1])=1+PM(j-1)
其中 j-1 是已经匹配的字符数

当 j=1 时出现不匹配(即t[1]≠s[1]), 则移动后下标 j = 1 + (-1) = 0
这时就需要在代码中判断当 j=0 时直接 i++, j++, 这样 j 又变成 1, 但是 i 变大了, 相当于t[1]与s[2]继续进行比较

next 表

使用部分匹配表求位移, 需要知道最后一个匹配字符的表值(也就是PM[j-1]), 如果把部分匹配表值右移一位, 就可以直接使用当前下标 j 获取表值(也就是Next[j])

部分匹配表最后一个 a 的 3 是不需要的, 因为能用到最后一个, 说明已经完全匹配了

这里还可以优化一下, 每次不匹配都需要 j=1+next[j] 有点麻烦, 如果 next 表在原来的基础上 +1 岂不美哉?

现在不匹配就可以直接 j=next[j] 了 🎉🎉🎉🎉

回到刚刚的例子:

next 表值的特殊意义:

当在 j 处遇到不匹配时, 跳转到 next[j] 处继续与主串比较

代码实现

例子与 BF 算法一致

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

#define Length 255

struct sstring {
    int length;
    char ch[Length];
};

// 手动生成 next 表
// 第一个 0 占位
int next[8] = { 0, 0, 1, 1, 1, 1, 2, 3 };

int find(sstring s, sstring t, int pos = 1) {
    int i = pos;
    int j = 1;

    int count = 0;

    while (i <= s.length && j <= t.length) {
        if (j == 0) {
            i++;
            j++;
        }
        else if (s.ch[i] == t.ch[j]) {
            count++;
            i++;
            j++;
        }
        else {
            j = next[j];
        }
    };

    printf("KMP 算法比较次数: %d\n", count); // 13

    if (j > t.length) {
        return i - t.length;
    }
    else {
        return -1;
    }
}



int main() {
    sstring s = { 23, "-BBC ABCDAB ABCDABDCABDE" }
    , t = { 7, "-ABCDABD" };

    int index = find(s, t);

    printf("第一个匹配字符下标: %d", index);
}

next 表代码实现

next[1] 一定等于 0
当 next[j]=k 时, 存在 $t_1t_2\cdots t_{k-1}=t_{j-k+1}\cdots t_{j-2}t_{j-1}$

为什么 1<k<j ? k-1 代表1~j-1 子串最大相等前后缀长度, 因此一定存在 k-1<j-1, 即 k 不会超过 j, 并且 $t_1t_2\cdots t_{k-1}$ 就是最长前缀

当 next[j]=k 时, next[j+1] 等于?

如果 t[k]=t[j] , 则有 $t_1t_2\cdots t_{k}=t_{j-k+1}\cdots t_{j-2}t_{j}$ , 因此 next[j+1] 等于 next[j]+1=k+1

比如

如果 t[k]≠t[j], 则将其看作一个迷你版模式匹配

因为 j'=next[k] < k, 所以 $t_1t_2\cdots t_{k}$ 一定是向右滑动, 如果滑一次不匹配, 则 j''=next[next[k]], 直到最后 $t_x=t_j$ 为止, 这时 next[j+1]=x+1

其他情况下都是 1

void buildNext(sstring t, int next[]) {
    int j = 1, k = 0;
    next[1] = 0; // 固定值
    while (j < t.length) {
        if (k == 0 || t.ch[j] == t.ch[k]) {
            k++;
            j++;
            next[j] = k;
        }
        else {
            k = next[k];
        }
    }
}