串的基本概念详解，串的模式匹配算法详解（暴力模式匹配算法详解、C++代码实现；KMP算法详解、C++代码实现）

串

串的定义和实现

字符串简称串，计算机上非数值处理的对象基本都是字符串数据。我们常见的信息检索系统 （如搜索引擎）、文本编辑程序（如Word）、问答系统、自然语言翻译系统等，都是以字符串数据作为处理对象的。本章详细介绍字符串的存储结构及相应的操作。

串的定义

串（string）是由零个或多个字符组成的有限序列。一般记为：
$$S{=}^{\prime }{a}_1{a}_2\cdots a_n^{\prime }(n\ge 0)$$
其中，$S$ 是串名，单引号括起来的字符序列是串的值；$a_i$可以是字母、数字或其他字符；串中字符的个数$n$称为串的长度。$n=0$时的串称为空串（用$\emptyset $表示）

串中任意多个连续的字符组成的子序列称为该串的子串，包含子串的串称为主串。某个字符在串中的序号称为该字符在串中的位置。子串在主串中的位置以子串的第一个字符在主串中的位置来表示。当两个串的长度相等且每个对应位置的字符都相等时，称这两个串是相等的。

例如，有串$A{=}^{\prime }ChinaBeijin{g}^{\prime }$，$B{=}^{\prime }Beijin{g}^{\prime }$，$C{=}^{\prime }Chin{a}^{\prime }$，则它们的长度分别为13，7 和 5。$B$和$C$是$A$的子串，$B$在$A$中的位置是 7，$C$在$A$中的位置是 1。

需要注意的是，由一个或多个空格（空格是特殊字符）组成的串称为空格串（注意，空格串不是空串），其长度为串中空格字符的个数。

串的逻辑结构和线性表极为相似，区别仅在于串的数据对象限定为字符集。在基本操作上， 串和线性表有很大差别。线性表的基本操作主要以单个元素作为操作对象，如查找、插入或删除某个元素等；而串的基本操作通常以子串作为操作对象，如查找、插入或删除一个子串等。

串的存储结构

1.定长顺序存储表示

类似于线性表的顺序存储结构，用一组地址连续的存储单元存储串值的字符序列。在串的定长顺序存储结构中，为每个串变量分配一个固定长度的存储区，即定长数组

#define MAXLEN 255      //预定义最大串长为255

struct SString {
    char ch[MAXLEN];    //每个分量存储一个字符
    int length;         //串的实际长度
};

串的实际长度只能小于等于MAXLEN，超过预定义长度的串值会被舍去，称为截断。串长有两种表示方法：

• 一是如上述定义描述的那样，用一个额外的变量len来存放串的长度；
• 二是在串值后面加一个不计入串长的结束标记字符"\0"，此时的串长为隐含值

2.堆分配存储表示

在一些串的操作（如插入、联接等）中，若串值序列的长度超过上界 MAXLEN，约定用"截断"法处理，要克服这种弊端，只能不限定串长的最大长度，即采用动态分配的方式。

堆分配存储表示仍然以一组地址连续的存储单元存放串值的字符序列，但它们的存储空间是在程序执行过程中动态分配得到的。

struct HString {
    char *ch;       //按串长分配存储区，ch指向串的基地址
    int length;     //串长度
};

3.块链存储表示

类似于线性表的链式存储结构，也可采用链表方式存储串值。由于串的特殊性（每个元素只有一个字符），在具体实现时，每个结点既可以存放一个字符，也可以存放多个字符。每个结点称为块，整个链表称为块链结构。图(a)是结点大小为4 （即每个结点存放4个字符）的链表，最后一个结点占不满时通常用"#"补上；图(b)是结点大小为1的链表。

串的基本操作

串的模式匹配

简单的模式匹配算法

子串的定位操作通常称为串的模式匹配，它求的是子串（常称模式串）在主串中的位置。这里采用定长顺序存储结构，给出一种不依赖于其他串操作的暴力匹配算法。

下图展示了模式T='abcac'和主串S的匹配过程，每次匹配失败后，都把模式T后移一位。算法思想为：从主串S的第一个字符起，与模式T的第一个字符比较, 若相等，则继续逐个比较后续字符；否则从主串的下一个字符起，重新和模式的字符比较；以此类推，直至模式T 中的每个字符依次和主串S中的一个连续的字符序列相等，则称匹配成功，函数值为与模式T中第一个字符相等的字符在主串S中的序号，否则称匹配不成功，函数值为零。

简单模式匹配算法的最坏时间复杂度为$O(nm)$，其中 $n$ 和 $m$ 分别为主串和模式串的长度。例如，当模式串为 0000001，而主串为0000000000000000000000000000000000000000000001时，由于模式中前6个字符均为"0"， 主串中前45个字符均为"0"，每趟匹配都是比较到模式的最后一个字符时才发现不等，指针 $i$ 需回溯 $40$ 次，总比较次数为$40\times 7=280$次。

简单模式匹配代码实现如下：

#include
#include

using namespace std;

#define MAXLEN 255      //预定义最大串长为255

struct SString {
    char ch[MAXLEN];    //每个分量存储一个字符
    int length;         //串的实际长度
};

//S为主串 T为子串
int Index(SString S, SString T) {
    int i = 1, j = 1;
    while (i <= S.length && j <= T.length)
        if (S.ch[i] == T.ch[j]) {               //继续比较后续字符
            ++i;
            ++j;
        } else {
            i = i - j + 2;      //指针后退重新开始匹配
            j = 1;
        }

    if (j > T.length)
        return i - T.length;    //匹配成功
    else
        return 0;               //匹配失败
}

int main() {

    SString S, T;

    strcpy(S.ch, "#ababcabcacdab");
    S.length = 13;
    strcpy(T.ch, "#abcac");
    T.length = 5;

    cout << Index(S, T) << endl;
    return 0;
}

运行结果：

6

串的模式匹配算法-KMP算法

上一节简单模式匹配过程中，在第三趟匹配中，$i=7、j=5$ 的字符比较不等，于是又从 $i=4、j=1$ 重新开始比较。然而，仔细观察会发现，$i=4$ 和 $j=1$，$i=5$ 和 $j=1$ 及 $i=6$ 和 $j=1$ 这三次比较都是不必进行的。从第三趟部分匹配的结果可知，主串中第4、5和6个字符'b'是'c'和'a'，(即模式中第2、3和4个字符)，因为模式中第一个字符是'a'，因此它无须再和这3个字符进行比较，而仅需将模式向右滑动3个字符的位置，继续进行 $i=7$、$j=2$ 时的比较即可。

在暴力匹配中，每趟匹配失败都是模式后移一位再从头开始比较。而某趟已匹配相等的字符序列是模式的某个前缀，这种频繁的重复比较相当于模式串在不断地进行自我比较，这就是其低效率的根源。因此，可以从分析模式本身的结构着手，如果已匹配相等的前缀序列中有某个后缀正好是模式的前缀，那么就可以将模式向后滑动到与这些相等字符对齐的位置，主串 $i$ 指针无须回溯，并从该位置开始继续比较。而模式向后滑动位数的计算仅与模式本身的结构有关，与主串无关（这里理解起来会比较困难，没关系，带着这个问题继续往后看）。

1.字符串的前缀、后缀和部分匹配值

要了解子串的结构，首先要弄清楚几个概念：前缀、后缀和部分匹配值。

• 前缀指除最后一个字符以外，字符串的所有头部子串；
• 后缀指除第一个字符外，字符串的所有尾部子串；
• 部分匹配值则为字符串的前缀和后缀的最长相等前后缀。

下面以’ababa’为例进行说明：

• 'a’的前缀和后缀都为空集，最长相等前后缀长度为0
• 'ab’的前缀为{a}，后缀为{b}，{a} $\cap$ {b} = $\emptyset $，最长相等前后缀长度为0。
• 'aba’的前缀为{a, ab}，后缀为{a, ba}，{a, ab} $ \cap$ {a, ba} = {a}，最长相等前后缀长度为1
• 'abab’的前缀{a, ab, aba} $\cap$ 后缀{b, ab, bab} = {ab}，最长相等前后缀长度为2。
• 'ababa '的前缀{a, ab, aba, abab} $\cap$ 后缀{a, ba, aba, baba} = {a, aba}，公共元素有两个，最长相等前后缀长度为3。

故字符串'ababa'，的部分匹配值为00123

这个部分匹配值有什么作用呢？

回到最初的问题，主串为a b a b c a b c a c b a b，子串为a b c a c。

利用上述方法容易写出子串'abcac'的部分匹配值为00010，将部分匹配值写成数组形式， 就得到了部分匹配值$（\mathrm{PartialMatch}，\mathrm{PM}）$的表。

编号	1	2	3	4	5
S	a	b	c	a	c
PM	0	0	0	1	0

下面用$\mathrm{PM}$表来进行字符串匹配：

（1）第一趟匹配过程∶

发现c与a不匹配，前面的2个字符'ab'是匹配的，查表可知，最后一个匹配字符b 对应的部分匹配值为 0，因此按照下面的公式算出子串需要向后移动的位数：
$$\mathbf{移动位数}=\mathbf{已匹配的字符数}-\mathbf{对应的部分匹配值}$$

因为2 - 0 = 2，所以将子串向后移动 2 位，然后进行第二趟匹配。

（2）第二趟匹配过程：

发现c与b不匹配，前面4 个字符'abca'是匹配的，最后一个匹配字符a对应的部分匹配值为 1，4 - 1 = 3，将字串向后移动3位，然后进行第三趟匹配：

（3）第三趟匹配过程：

子串全部比较完成，匹配成功。整个匹配过程中，主串始终没有回退，故$\mathrm{KMP}$算法可以在$O(n+m)$的时间数量级上完成串的模式匹配操作，大大提高了匹配效率。

某趟发生失配时，如果对应的部分匹配值为0，那么表示已匹配相等序列中没有相等的前后缀，此时移动的位数最大，直接将子串首字符后移到主串 $i$ 位置进行下一趟比较；如果已匹配相等序列中存在最大相等前后缀（可理解为首尾重合），那么将子串向右滑动到和该相等前后缀对齐（这部分字符下一趟显然不需要比较），然后从主串 $i$ 位置进行下一趟比较。

2.KMP算法的原理是什么：

我们刚刚学会了怎样计算字符串的部分匹配值、怎样利用子串的部分匹配值快速地进行字符串匹配操作，但公式 “移动位数=已匹配的字符数-对应的部分匹配值” 的意义是什么呢

如图(a)所示，当c与b不匹配时，已匹配'abca'的前缀a和后缀a为最长公共元素。已知前缀a与b、c均不同，与后缀a相同，故无须比较，直接将子串移动**“已匹配的字符数-对应的部分匹配值”**，用子串前缀后面的元素与主串匹配失败的元素开始比较即可，如图(b)所示。

图(a) 失配后移动情况 图(b) 直接移动到合适位置

对算法的改进方法：

已知：右移位数 = 已匹配字符数 - 对应的部分匹配值

写成：$\mathrm{Move}=(\mathrm{j}-1)-\mathrm{PM}[\mathrm{j}-1]$。

使用部分匹配值时，每当匹配失败，就去找它前一个元素的部分匹配值，这样使用起来有些不方便，所以将$\mathrm{PM}$表右移一位，这样哪个元素匹配失败，直接看它自己的部分匹配值即可。

将上例中字符串'abcac'的$\mathrm{PM}$表右移一位，就得到了$\mathrm{next}$数组：

编号	1	2	3	4	5
S	a	b	c	a	c
next	-1	0	0	0	1

我们注意到：

• 第一个元素右移以后空缺的用 -1来填充，因为若是第一个元素匹配失败，则需要将子串向右移动一位，而不需要计算子串移动的位数。
• 最后一个元素在右移的过程中溢出，因为原来的子串中，最后一个元素的部分匹配值是其下一个元素使用的，但显然已没有下一个元素，故可以舍去。

这样，上式就改写为：
$$\mathrm{Move}=(\mathrm{j}-1)-\mathrm{next}[\mathrm{j}]$$
相当于将子串的比较指针j回退到
$$\mathrm{j}=\mathrm{j}-\mathrm{Move}=\mathrm{j}-((\mathrm{j}-1)-\mathrm{next}[\mathrm{j}])=\mathrm{next}[\mathrm{j}]+1$$
有时为了使公式更加简洁、计算简单，将 $\mathrm{next}$数组整体 +1 。

因此，上述子串的$\mathrm{next}$数组也可以写成

编号	1	2	3	4	5
S	a	b	c	a	c
next	0	1	1	1	2

最终得到子串指针变化公式j = next[j]。在实际匹配过程中，子串在内存里是不会移动的， 而是指针在变化，书中画图举例只是为了让问题描述得更加形象。next[j]的含义是∶在子串的第j个字符与主串发生失配时，则跳到子串的next[j]位置重新与主串当前位置进行比较。

推理next数组的一般公式：

主串为$S_1{S}_2\dots S_n$，模式串为$P_1{P}_2\dots P_m$，当主串中第i个字符与模式串中第j个字符失配时，假设此时应与模式中第$\mathrm{k}(\mathrm{k}<\mathrm{j})$ 个字符继续比较，则模式中前个字符$\mathrm{k}-1$ 的子串必须满足下列条件，且不可能存在 ${\mathrm{k}}^{\prime }>\mathrm{k}$ 满足下列条件：
$${}^{\prime }{\mathrm{P}}_1{\mathrm{P}}_2\dots {\mathrm{P}}_{\mathrm{k}-1}^{\prime }{=}^{\prime }{\mathrm{P}}_{\mathrm{j}-\mathrm{k}+1}{\mathrm{P}}_{\mathrm{j}-\mathrm{k}+2}\dots {\mathrm{P}}_{\mathrm{j}-1}^{\prime }$$
若存在满足如上条件的子串，则发生失配时，仅需将模式向右滑动至模式中第k个字符和主串第i个字符对齐，此时模式中前k-1个字符的子串必定与主串中第i个字符之前长度为k-1 的子串相等。由此，只需从模式第k个字符与主串第i个字符继续比较即可，如下图所示：

当模式串已匹配相等序列中不存在满足上述条件的子串时（可以看成k=1）,显然应该将模式串右移j-1位，让主串第i个字符和模式第一个字符进行比较，此时右移位数最大。

当模式串第一个字符（j=1）与主串第i个字符发生失配时，规定next[1]=0将模式串右移一位，从主串的下一个位置（i+1）和模式串的第一个字符继续比较。

通过上述分析可以得出next函数的公式：
$$\mathrm{next}[\mathrm{j}]=\{\begin{array}{ll}0& \mathrm{j}=1\\ \max \{k|1<\mathrm{k}<\mathrm{j}{\mathrm{且}}^{\prime }{\mathrm{P}}_1\dots {\mathrm{P}}_{\mathrm{k}-1}^{\prime }{=}^{\prime }{\mathrm{P}}_{\mathrm{j}-\mathrm{k}+1}\dots {\mathrm{P}}_{\mathrm{j}-1}^{\prime }\}& 当此集合不空时\\ 1& 其他情况\end{array}$$
首先由公式可知：
$$\mathrm{next}[1]=0$$
设 $\mathrm{next}[\mathrm{j}]=\mathrm{k}$，此时 $\mathrm{k}$ 应该满足的条件在上文已经描述过了。

此时 $\mathrm{next}[\mathrm{j}+1]=?$ 可能有两种情况：

(1) 若${\mathrm{P}}_{\mathrm{k}}={\mathrm{P}}_{\mathrm{j}}$ ，则表明在模式串中：
$${}^{\prime }{\mathrm{P}}_1\dots {\mathrm{P}}_{\mathrm{k}-1}{\mathrm{P}}_{\mathrm{k}}^{\prime }{=}^{\prime }{\mathrm{P}}_{\mathrm{j}-\mathrm{k}+1}\dots {\mathrm{P}}_{\mathrm{j}-1}{\mathrm{P}}_{\mathrm{j}}^{\prime }$$
并且不可能存在${\mathrm{k}}^{\prime }>\mathrm{k}$满足上述条件，此时$\mathrm{next}[\mathrm{j}+1]=\mathrm{k}+1$ 即：
$$\mathrm{next}[\mathrm{j}+1]=\mathrm{next}[\mathrm{j}]+1$$
(2)若${\mathrm{P}}_{\mathrm{k}}\ne {\mathrm{P}}_{\mathrm{j}}$，则表明在模式串中：
$${}^{\prime }{\mathrm{P}}_1\dots {\mathrm{P}}_{\mathrm{k}-1}{\mathrm{P}}_{\mathrm{k}}^{\prime }{\ne }^{\prime }{\mathrm{P}}_{\mathrm{j}-\mathrm{k}+1}\dots {\mathrm{P}}_{\mathrm{j}-1}{\mathrm{P}}_{\mathrm{j}}^{\prime }$$
此时可以把求 $\mathrm{next}$ 函数值的问题视为一个模式匹配的问题。用前缀${\mathrm{P}}_1\dots {\mathrm{P}}_{\mathrm{k}}$去跟后缀${\mathrm{P}}_{\mathrm{j}-\mathrm{k}+1}\dots {\mathrm{P}}_{\mathrm{j}}$匹配，则当${\mathrm{P}}_{\mathrm{k}}\ne {\mathrm{P}}_{\mathrm{j}}$时应将 ${\mathrm{P}}_1\dots {\mathrm{P}}_{\mathrm{k}}$ 向右滑动至以第 $\mathrm{next}[\mathrm{k}]$ 个字符与 ${\mathrm{P}}_{\mathrm{j}}$ 比较，如果 ${\mathrm{P}}_{\mathrm{next}[\mathrm{k}]}$ 与 ${\mathrm{P}}_{\mathrm{j}}$ 还是不匹配，那么需要寻找长度更短的相等前后缀，下一步继续用 ${\mathrm{P}}_{\mathrm{next}[\mathrm{next}[\mathrm{k}]]}$ 与 ${\mathrm{P}}_{\mathrm{j}}$ 比较， 以此类推，直到找到某个更小的${\mathrm{k}}^{\prime }=\mathrm{next}[\mathrm{next}\dots [\mathrm{k}]](1<{\mathrm{k}}^{\prime }<\mathrm{k}<\mathrm{j})$，满足条件：
$${}^{\prime }{\mathrm{P}}_1\dots {\mathrm{P}}_{k’}^{\prime }{=}^{\prime }{\mathrm{P}}_{\mathrm{j}-{\mathrm{k}}^{\prime }+1}\dots {\mathrm{P}}_{\mathrm{j}}^{\prime }$$
则：$\mathrm{next}[\mathrm{j}+1]={\mathrm{k}}^{\prime }+1$。

也可能不存在任何 ${\mathrm{k}}^{\prime }$ 满足上述条件，即不存在长度更短的相等前缀后缀，令 $\mathrm{next}[\mathrm{j}+1]=1$

下面举一个简单的next数组推理例子：

j	1	2	3	4	5	6	7	8	9
模式	a	b	a	a	b	c	a	b	a
next[j]	0	1	1	2	2	3	?	?	?

模式串中已经求得6个字符的next值：

• 求next[7]，因为next[6]=3，所以比较${\mathrm{P}}_6$和${\mathrm{P}}_3$（'c'!='a'），得到比较结果：${\mathrm{P}}_6\ne {\mathrm{P}}_3$；又因为next[3]=1，所以比较${\mathrm{P}}_6$和${\mathrm{P}}_1$（'c'!='a'），得到比较结果：${\mathrm{P}}_6\ne {\mathrm{P}}_1$；又因为next[1]=0，即不存在长度更短的相等前缀后缀，所以next[7]=1。
• 求next[8]，因为next[7]=1，所以比较${\mathrm{P}}_7$和${\mathrm{P}}_1$，得到比较结果：${\mathrm{P}}_7={\mathrm{P}}_1$，所以next[8]=next[7]+1=2。
• 求next[9]，因为next[8]=2，所以比较${\mathrm{P}}_8$和${\mathrm{P}}_2$，得到比较结果：${\mathrm{P}}_8={\mathrm{P}}_2$，所以next[9]=next[8]+1=3。

根据上述分析写出求next值的程序如下：

#define MAXLEN 255      //预定义最大串长为255

struct SString {
    char ch[MAXLEN];    //每个分量存储一个字符
    int length;         //串的实际长度
};

//构造模式的next数组
void get_next(SString T, int next[]) {
    int i = 1, j = 0;
    next[1] = 0;

    while (i < T.length)
        if (j == 0 || T.ch[i] == T.ch[j]) {
            ++i;
            ++j;
            next[i] = j;    //若Pi=Pj 则next[j+1]=next[j]+1
        } else
            j = next[j];    //否则令j=next[j]，循环继续
}

与next 数组的求解相比，$\mathrm{KMP}$的匹配算法相对要简单很多，它在形式上与简单的模式匹配算法很相似。不同之处仅在于当匹配过程产生失配时，指针i不变，指针j退回到 next[j]的位置并重新进行比较，并且当指针j为0时，指针i和j同时加1。即若主串的第i个位置和模式串的第一个字符不等，则应从主串的第i+1个位置开始匹配。具体代码如下：

//S为主串 T为子串
int Index_KMP(SString S, SString T, int next[]) {
    int i = 1, j = 1;

    while (i <= S.length && j <= T.length)
        if (j == 0 || S.ch[i] == T.ch[j]) {
            ++i;
            ++j;                //继续比较后续字符
        } else {
            j = next[j];        //模式串向右移动
        }


    if (j > T.length)
        return i - T.length;    //匹配成功
    else
        return 0;
}

完整代码如下：

#include 
#include 

using namespace std;

#define MAXLEN 255      //预定义最大串长为255

struct SString {
    char ch[MAXLEN];    //每个分量存储一个字符
    int length;         //串的实际长度
};

//构造模式的next数组
void get_next(SString T, int next[]) {
    int i = 1, j = 0;
    next[1] = 0;

    while (i < T.length)
        if (j == 0 || T.ch[i] == T.ch[j]) {
            ++i;
            ++j;
            next[i] = j;    //若Pi=Pj 则next[j+1]=next[j]+1
        } else
            j = next[j];    //否则令j=next[j]，循环继续
}

//S为主串 T为子串
int Index_KMP(SString S, SString T, int next[]) {
    int i = 1, j = 1;

    while (i <= S.length && j <= T.length)
        if (j == 0 || S.ch[i] == T.ch[j]) {
            ++i;
            ++j;                //继续比较后续字符
        } else {
            j = next[j];        //模式串向右移动
        }


    if (j > T.length)
        return i - T.length;    //匹配成功
    else
        return 0;
}


int main() {
    SString S, T;
    int next[MAXLEN];

    strcpy(S.ch, "#ababcabcacdab");
    S.length = 13;
    strcpy(T.ch, "#abcac");
    T.length = 5;

    get_next(T, next);

    cout << Index_KMP(S, T, next) << endl;

    return 0;
}

运行结果

6

小结：

尽管普通模式匹配的时间复杂度是 $\mathrm{O}(\mathrm{mn})$，$\mathrm{KMP}$算法的时间复杂度是 $\mathrm{O}(\mathrm{m}+\mathrm{n})$，但在一般情况下，普通模式匹配的实际执行时间近似为$\mathrm{O}(\mathrm{m}+\mathrm{n})$，因此至今仍被采用。$\mathrm{KMP}$算法仅在主串与子串有很多 “部分匹配” 时才显得比普通算法快得多，其主要优点是主串不回溯。