大话数据结构学习笔记（五）——串

串（string）是由零个或多个字符组成的有限序列，又名叫字符串。

1 串的定义

一般记为s="a[1]a[2]......a[n]"(n≥0)，其中，s是串的名称，用双引号（有些书中也用单引号）括起来的字符序列是串的值，注意引号不属于串的内容。a[i](1≤i≤n)可以是字母、数字或其他字符，i就是该字符在串中的位置。串中的字符数目n称为串的长度，定义中谈到“有限”是指长度n是一个有限的数值。零个字符的串称为空串（nullstring），它的长度为零，可以直接用两双引号“""”表示，也可以用希腊字母“Φ”来表示。所谓的序列，说明串的相邻字符之间具有前驱和后继的关系。

空格串，是只包含空格的串。注意它与空串的区别，空格串是有内容有长度的，而且可以不止一个空格。
子串与主串，串中任意个数的连续字符组成的子序列称为该串的子串，相应地，包含子串的串称为主串。
子串在主串中的位置就是子串的第一个字符在主串中的序号。

2 串的比较

串的比较是通过组成串的字符之间的编码来进行的，而字符的编码指的是字符在对应字符集中的序号。

计算机中的常用字符是使用标准的ASCII编码，更准确一点，由7位二进制数表示一个字符，总共可以表示128个字符。后来发现一些特殊符号的出现，128个不够用，于是扩展ASCII码由8位二进制数表示一个字符，总共可以表示256个字符，这已经足够满足以英语为主的语言和特殊符号进行输入、存储、输出等操作的字符需要了。可是，单我们国家就有除汉族外的满、回、藏、蒙古、维吾尔等多个少数民族文字，换作全世界估计要有成百上千种语言与文字，显然这256个字符是不够的，因此后来就有了Unicode编码，比较常用的是由16位的二进制数表示一个字符，这样总共就可以表示2^16个字符，约是6.5万多个字符，足够表示世界上所有语言的所有字符了。当然，为了和ASCII码兼容，Unicode的前256个字符与ASCII码完全相同。

那么对于两个串不相等时，如何判定它们的大小呢。我们这样定义：
给定两个串：s="a[1]a[2]......a[n]"，t="b[1]b[2]......b[n]"，当满足以下条件之一
时，s<t。

n<m，且a[i]=b[i](i=1,2,...,n)。例如当s="hap"，t="happy"，就有s<t。因为t比s多出了两个字母。
存在某个k≤min(m,n)，使得a[i]=b[i](i=1,2,...,k-1)，a[k]<b[k]。

3 串的抽象数据类型

串的基本操作与线性表是有很大差别的。线性表更关注的是单个元素的操作，比如查找一个元素，插入或删除一个元素，但串中更多的是查找子串位置、得到指定位置子串、替换子串等操作。

ADT 串(string)
Data
	串中元素仅由一个字符组成， 相邻元素具有前驱和后继关系。
Operation
	StrAssign(T, *chars): 			生成一个其值等于字符串常量chars的串
	StrCopy(T, S): 					串S存在，由串S复制得串T。
	ClearString(S): 				串S存在，将串清空。
	StringEmpty(S): 				若串S为空，返回true，否则返回false。
	StrLength(S): 					返回串S的元素个数，即串的长度。
	StrCompare(S, T): 				若S>T，返回值>0，若S=T，返回0，若S<T，返回值<0
	Concat(T, S1, S2): 				用T返回由S1和S2联接而成的新串。
	SubString(Sub, S, pos, len): 	串S存在，1≤pos≤StrLength(S)，且0≤len≤StrLength(S)-pos+1，用Sub表示回串S的第pos个字符起长度为len的子串
	Index(S, T, pos): 				串S和T存在，T是非空串，1≤pos≤StrLength(T)。若主串S中存在和串T值相同的子串，则返第pos个字符之后第一次出现的位置，否则返回0
	Replace(S, T, V): 				串S、T和V存在，T是非空串。用V替换主与T相等的不重叠的子串。
	StrInsert(S, pos, T): 			串S和T存在，1≤pos≤StrLength(S)+1。在串S的第pos个字符之前插入串T。
	StrDelete(S, pos, len): 		串S存在，1≤pos≤StrLength(S)-len+1从串S中删除第pos个字符起长度为len的子串
endADT

一个操作Index的实现算法：

// T为非空串。若主串S中第pos个字符之后存在于T相等的子串，则返回第一个这样的子串在S中的位置，否则返回0
int Index(String s, String T, int pos)
{
    int n, m, i;
    String sub;
    if (pos > 0)
    {
        // 得到主串S的长度
        n = StrLength(S);
        // 得到子串T的长度
        m = StrLength(T);
        i = pos;
        while (i <= n - m + 1)
        {
            // 取主串第i个位置长度与T相等的子串给sub
            SubString(sub, S, i, m);
            // 如果两串不相等
            if (StrCompare(sub, T) != 0)
                ++ i;
            // 如果两串相等
            else 
                // 则返回i值
                return i;
        }
    }
    // 若无子串与T相等，返回0
    return 0;
}

4 串的存储结构

4.1 串的顺序存储结构

串的顺序存储结构是用一组地址连续的存储单元来存储串中的字符序列的。按照预定义的大小，为每个定义的串变量分配一个固定长度的存储区。一般是用定长数组来定义。

既然是定长数组，就存在一个预定义的最大串长度，一般可以将实际的串长度值保存在数组的0下标位置，有的书中也会定义存储在数组的最后一个下标位置。但也有些编程语言不想这么干，觉得存个数字占个空间麻烦。它规定在串值后面加一个不计入串长度的结束标记字符，比如"\0"来表示串值的终结，这个时候，你要想知道此时的串长度，就需要遍历计算一下才知道了，其实这还是需要占用一个空间，何必呢。

刚才讲的串的顺序存储方式其实是有问题的，因为字符串的操作，比如两串的连接Concat、新串的插入StrInsert，以及字符串的替换Replace，都有可能使得串序列的长度超过了数组的长度Max-Size。

于是对于串的顺序存储，有一些变化，串值的存储空间可在程序执行过程中动态分配而得。比如在计算机中存在一个自由存储区，叫做“堆”。这个堆可由C语言的动态分配函数malloc()和free()来管理。

4.2 串的链式存储结构

对于串的链式存储结构，与线性表是相似的，但由于串结构的特殊性，结构中的每个元素数据是一个字符，如果也简单的应用链表存储串值，一个结点对应一个字符，就会存在很大的空间浪费。因此，一个结点可以存放一个字符，也可以考虑存放多个字符，最后一个结点若是未被占
满时，可以用"#"或其他非串值字符补全，如下图所示。

当然，这里一个结点存多少个字符才合适就变得很重要，这会直接影响着串处理的效率，需要根据实际情况做出选择。
但串的链式存储结构除了在连接串与串操作时有一定方便之外，总的来说不如顺序存储灵活，性能也不如顺序存储结构好。

5 朴素的模式匹配算法

假设我们要从下面的主串S="goodgoogle"中，找到T="google"这个子串的位置。我们通常需要下面的步骤。

主串S第一位开始，S与T前三个字母都匹配成功，但S第四个字母是d而T的是g。第一位匹配失败。如下图所示，其中竖直连线表示相等，闪电状弯折连线表示不等。
主串S第二位开始，主串S首字母是o，要匹配的T首字母是g，匹配失败，如下图所示。
主串S第三位开始，主串S首字母是o，要匹配的T首字母是g，匹配失败，如下图所示。
主串S第四位开始，主串S首字母是d，要匹配的T首字母是g，匹配失败，如下图所示。
主串S第五位开始，S与T，6个字母全匹配，匹配成功，如下图所示。

简单的说，就是对主串的每一个字符作为子串开头，与要匹配的字符串进行匹配。对主串做大循环，每个字符开头做T的长度的小循环，直到匹配成功或全部遍历完成为止。
前面我们已经用串的其他操作实现了模式匹配的算法Index。现在考虑不用串的其他操作，而是只用基本的数组来实现同样的算法。注意我们假设主串S和要匹配的子串T的长度存在S[0]与T[0]中。实现代码如下：

// 返回子串T在主串S中第pos个字符之后的位置。若不存在，则函数返回为0。
// T非空，1≤pos≤StrLength(S)。
int Index(String S, String T, int pos)
{
    // i用于主串S中当前位置下标，若pos不为1，则从pos位置开始匹配
    int i = pos;
    // j用于子串T中当前位置下标值
    int j = 1;
    // 若i小于S长度且j小于T的长度时循环
    while (i <= S[0] && j <=T[0])
    {
        // 两字母相等则继续
        if (S[i] == T[j])
        {
            ++ i;
            ++ j;
        }
        // 指针后退重新开始匹配
        else 
        {
            // i退回到上次匹配首位的下一位
            i = i - j + 2;
            // j退回到子串T的首位
            j = 1;
        }
    }
    if (j = T[0])
        return i - T[0];
    else 
        return 0;
}

分析一下，最好的情况是什么？那就是一开始就区配成功，比如"googlegood"中去找"google"，时间复杂度为O(1)。稍差一些，如果像刚才例子中第二、三、四位一样，每次都是首字母就不匹配，那么对T串的循环就不必进行了，比如"abcdef-google"中去找"google"。那么时间复杂度为O(n+m)，其中n为主串长度，m为要匹配的子串长度。根据等概率原则，平均是(n+m)/2次查找，时间复杂度为O(n+m)。
那么最坏的情况又是什么？就是每次不成功的匹配都发生在串T的最后一个字符。举一个很极端的例子。主串为S="00000000000000000000000000000000000000000000000001"，而要匹配的子串为T="0000000001"，前者是有49个"0"和1个"1"的主串，后者是9个"0"和1个"1"的子串。在匹配时，每次都得将T中字符循环到最后一位才发现：哦，原来它们是不匹配的。这样等于T串需要在S
串的前40个位置都需要判断10次，并得出不匹配的结论，如下图所示：

直到最后第41个位置，因为全部匹配相等，所以不需要再继续进行下去。如果最终没有可匹配的子串，比如是T="0000000002"，到了第41位置判断不匹配后同样不需要继续比对下去。因此最坏情况的时间复杂度为O((n-m＋1)*m)。

6 KMP模式匹配算法

很多年前我们的科学家们，觉得像这种有多个0和1重复字符的字符串，模式匹配需要挨个遍历的算法是非常糟糕的。于是有三位前辈，D.E. Knuth、J.H. Morris和V.R. Pratt（其中Knuth和Pratt共同研究，Mor-ris独立研究）发表一个模式匹配算法，可以大大避免重复遍历的情况，我们把它称之为克努特—莫里斯—普拉特算法，简称KMP算法。

6.1 KMP模式匹配算法原理

如果主串S="abcdefgab"，其实还可以更长一些，我们就省略掉只保留前9位，我们要匹配的T="abcdex"，那么如果用前面的朴素算法的话，前5个字母，两个串完全相等，直到第6个字母， "f"与"x"不等，如下图中的①所示。

接下来，按照朴素模式匹配算法，应该是如上图中的流程②③④⑤⑥。即主串S中当i=2、3、4、5、6时，首字符与子串T的首字符均不等。
似乎这也是理所当然，原来的算法就是这样设计的。可仔细观察发现。对于要匹配的子串T来说，"abcdex"首字母"a"与后面的串"bcdex"中任意一个字符都不相等。也就是说，既然"a"不与自己后面的子串中任何一字符相等，那么对于上图中的①来说，前五位字符分别相等，意味着
子串T的首字符"a"不可能与S串的第2位到第5位的字符相等。在上图中，②③④⑤的判断都是多余。
注意这里是理解KMP算法的关键。如果我们知道T串中首字符"a"与T中后面的字符均不相等（注意这是前提，如何判断后面再讲）。而T串的第二位的"b"与S串中第二位的"b"在上图的①中已经判断是相等的，那么也就意味着，T串中首字符"a"与S串中的第二位"b"是不需要判断也知道它们是不可能相等了，这样上图的②这一步判断是可以省略的，如下图所示。

同样道理，在我们知道T串中首字符"a"与T中后面的字符均不相等的前提下，T串的"a"与S串后面的"c"、"d"、"e"也都可以在①之后就可以确定是不相等的，所以这个算法当中②③④⑤没有必要，只保留①⑥即可，如下图所示。

之所以保留⑥中的判断是因为在①中T[6]≠S[6]，尽管我们已经知道T[1]≠T[6]，但也不能断定T[1]一定不等于S[6]，因此需要保留⑥这一步。
有人就会问，如果T串后面也含有首字符"a"的字符怎么办呢？
我们来看下面一个例子，假设S="abcababca"，T="abcabx"。对于开始的判断，前5个字符完全相等，第6个字符不等，如下图中的①。此时，根据刚才的经验，T的首字符"a"与T的第二位字符"b"、第三位字符"c"均不等，所以不需要做判断，下图中的朴素算法步骤②③都是多余。

因为T的首位"a"与T第四位的"a"相等，第二位的"b"与第五位的"b"相等。而在①时，第四位的"a"与第五位的"b"已经与主串S中的相应位置比较过了，是相等的，因此可以断定，T的首字符"a"、第二位的字符"b"与S的第四位字符和第五位字符也不需要比较了，肯定也是相等的——之前比较过了，还判断什么，所以④⑤这两个比较得出字符相等的步骤也可以省略。
也就是说，对于在子串中有与首字符相等的字符，也是可以省略一部分不必要的判断步骤。如下图所示，省略掉右图的T串前两位"a"与"b"同S串中的4、 5位置字符匹配操作。

对比这两个例子，我们会发现在①时，我们的i值，也就是主串当前位置的下标是6，②③④⑤，i值是2、3、4、5，到了⑥，i值才又回到了6。即我们在朴素的模式匹配算法中，主串的i值是不断地回溯来完成的。而我们的分析发现，这种回溯其实是可以不需要的——正所谓好马不吃回头草，我们的KMP模式匹配算法就是为了让这没必要的回溯不发生。
既然i值不回溯，也就是不可以变小，那么要考虑的变化就是j值了。通过观察也可发现，我们屡屡提到了T串的首字符与自身后面字符的比较，发现如果有相等字符，j值的变化就会不相同。也就是说，这个j值的变化与主串其实没什么关系，关键就取决于T串的结构中是否有重复的问题。
比如上上上图中，由于T="abcdex"，当中没有任何重复的字符，所以j就由6变成了1。而上图中，由于T="abcabx"，前缀的"ab"与最后"x"之前串的后缀"ab"是相等的。因此j就由6变成了3。因此，我们可以得出规律，j值的多少取决于当前字符之前的串的前后缀的相似度。

我们把T串各个位置的j值的变化定义为一个数组next，那么next的长度就是T串的长度。于是我们可以得到下面的函数定义：

n e x t (j) = {\begin{cases} 0, 当 j = 1 时 \\ M a x {k | 1 < k < j, 且^{'} p_{1} Λ {p_{k - 1}}^{'} =^{'} p_{j - k + 1} Λ {p_{j - 1}}^{'}} 当 此 集 合 不 空 时 \\ 1, 其 他 情 况 \end{cases}

$next(j)=\begin{cases} 0, \quad 当j=1时\\ Max\{k|1<k<j,且'{p_1} \Lambda {p_{k-1}}'='{p_{j-k+1}} \Lambda {p_{j-1}}' \} 当此集合不空时\\ 1, \quad 其他情况 \end{cases}$

6.2 next数组值推导

6.2.1 T="abcdex"

j	模式串T	next[j]
123456	abcdex	011111

当j=1时，next[1]=0；
当j=2时，j由1到j-1就只有字符"a"，属于其他情况，next[2]=1；
当j=3时，j由1到j-1串是"ab"，显然"a"与"b"不相等，属于其他情况，next[3]=1；
以后同理，所以最终此T串的next[j]为011111。

6.2.2 T="abcabx"

j	模式串T	next[j]
123456	abcabx	011123

当j=1时，next[1]=0；
当j=2时，同上例说明，next[2]=1；
当j=3时，同上，next[3]=1;
当j=4时，同上，next[4]=1；
当j=5时，此时j由1到j-1的串是"abca"，前缀字符"a"与后缀字符"a"相等（前缀用下划线表示，后缀用斜体表示），因此可推算出k值为2（由"p[1]...p[k-1]"="p[j-k+1]...p[j-1]"，得到p[1]=p[4]），因此next[5]=2；
当j=6时，j由1到j-1的串是"abcab"，由于前缀字符"ab"与后缀字符"ab"相等，所以next[6]=3。

我们可以根据经验得到：如果前后缀一个字符相等，k值是2，两个字符相等k值是3，n个相等k值就是n-1。

6.2.3 T="ababaaaba"

j	模式串T	next[j]
123456789	ababaaaba	011234223

当j=1时，next[1]=0；
当j=2时，同上例说明，next[2]=1；
当j=3时，同上，next[3]=1;
当j=4时，j由1到j-1的串是"aba"，前缀字符"a"与后缀字符"a"相等，next[4]=2；
当j=5时，j由1到j-1的串是"abab"，由于前缀字符"ab"与后缀"ab"相等，所以next[5]=3；
当j=6时，j由1到j-1的串是"ababa"，由于前缀字符"aba"与后缀"aba"相等，所以next[6]=4；
当j=7时，j由1到j-1的串是"ababaa"，由于前缀字符"ab"与后缀"aa"并不相等，只有"a"，相等，所以next[7]=2；
当j=8时，j由1到j-1的串是"ababaaa"，只有"a"相等，所以next[8]=2；
当j=9时，j由1到j-1的串是"ababaaab"，由于前缀字符"ab"与后缀"ab"相等，所以next[9]=3。

6.2.4 T="aaaaaaaab"

j	模式串T	next[j]
123456789	aaaaaaaab	012345678

当j=1时，next[1]=0；
当j=2时，同上例说明，next[2]=1；
当j=3时，j由1到j-1的串是"aa"，前缀字符"a"与后缀字符"a"相等，next[3]=2；
当j=4时，j由1到j-1的串是"aaa"，前缀字符"aa"与后缀字符"aa"相等，next[4]=3；
......
当j=9时，j由1到j-1的串是"aaaaaaaa"，前缀字符"aaaaaaa"与后缀字符"aaaaaaa"相等，next[9]=8。

6.3 KMP模式匹配算法实现

代码如下：

// 通过计算返回子串T的next数组
void get_next(String T, int *next)
{
    int i, j;
    i = 1;
    j = 0;
    next[1] = 0;
    // 此处T[0]表示串T的长度
    while (i < T[0])
    {
        // T[i]表示后缀的单个字符
        // T[j]表示前缀的单个字符
        if (j == 0 || T[i] == T[j])
        {
            ++ i;
            ++ j;
            next[i] = j;
        }
        else
            // 若字符不相同，则j值回溯
            j = next[j];
    }
}

这段代码的目的就是为了计算出当前要匹配的串T的next数组。

// 返回子串T在主串S中第pos个字符后的位置。若不存在，则函数返回值为0。
// T非空，1≤pos≤StrLength(S)。
int Index_KMP(String S, String T, int pos)
{
    // i用于主串S当前位置下标值，若pos不为1，则从pos位置开始匹配
    int i = pos;
    // j用于子串T中当前位置下标值
    int j = 1;
    // 定义一next数组
    int next[255];
    // 对串T作分析，得到next数组
    get_next(T, next);
    // 若i小于S的长度且j小于T的长度时，循环继续
    while (i <= S[0] && j <= T[0])
    {
        // 两字母相等则继续，相对于朴素算法增加了j=0判断
        if (j = 0 || S[i] == T[j])
        {
            ++ i;
            ++ j;
        }
        // 指针后退重新开始匹配
        else 
        {
            // j退回合适的位置，i值不变
            j = next[j];
        }
    }
    if (j > T[0])
        return i - T[0];
    else 
        return 0;
}

相对于朴素匹配算法增加的代码，改动不算大，关键就是去掉了i值回溯的部分。对于get_next函数来说，若T的长度为m，因只涉及到简单的单循环，其时间复杂度为O(m)，而由于i值的不回溯，使得index_KMP算法效率得到了提高，while循环的时间复杂度为O(n)。因此，整个算法的时间复杂度为O(n＋m)。相较于朴素模式匹配算法的O((n-m+1)*m)来说，是要好一些。
这里也需要强调，KMP算法仅当模式与主串之间存在许多“部分匹配”的情况下才体现出它的优势，否则两者差异并不明显。

6.4 KMP模式匹配算法改进

假设T串的第二、三、四、五位置的字符都与首位的"a"相等，那么可以用首位next[1]的值去取代与它相等的字符后续next[j]的值，这是个很好的办法。因此我们对求next函数进行了改良。
假设取代的数组为nextval，增加了加粗部分，代码如下：

// 求模式串T的next函数修正值并存入数组nextval
void get_nextval(String T, int *nextVal)
{
    int i, j;
    i = 1;
    j = 0;
    nextval[1] = 0;
    // 此处T[0]表示串T的长度
    while (i < T[0])
    {
        // T[i]表示后缀的单个字符
        // T[j]表示前缀的单个字符
        if (j == 0 || T[i] == T[j])
        {
            ++ i;
            ++ j;
            // 若当前字符与前缀字符不同
            if (T[i] != T[j])
                // 则当前的j为nextval在i位置的值
                nextval[i] = j;
            else 
                // 如果与前缀字符相同，则将前缀字段的nextval值赋值给nextval在i位置的值
                nextval[i] = nextval[j];
        }
        else
            // 若字符不相同，则j值回溯
            j = nextval[j];
    }
}

6.5 nextval数组值推导

6.5.1 T="ababaaaba"

j	模式串T	next[j]	nextval[j]
123456789	ababaaaba	011234223	010104210

6.5.2 T="aaaaaaaab"

j	模式串T	next[j]	nextval[j]
123456789	aaaaaaaab	012345678	000000009

总结改进过的KMP算法，它是在计算出next值的同时，如果a位字符与它next值指向的b位字符相等，则该a位的nextval就指向b位的nextval值，如果不等，则该a位的nextval值就是它自己a位的next的值。

posted @ 2022-05-09 15:00 JapserTang 阅读(455) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 大话数据结构学习笔记（九）——排序

· 大话数据结构学习笔记（四）——栈与队列

· 04字符串

· KMP算法（串的模式匹配算法）（未完待续......）

· KMP 算法

阅读排行：
· 阿里最新开源QwQ-32B，效果媲美deepseek-r1满血版，部署成本又又又降低了！
· 单线程的Redis速度为什么快？
· SQL Server 2025 AI相关能力初探
· AI编程工具终极对决：字节Trae VS Cursor，谁才是开发者新宠？
· 展开说说关于C#中ORM框架的用法！

公告

昵称： JapserTang
园龄： 3年3个月
粉丝： 1
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

Clearoloar