第5天串
1 串的抽象数据类型的定义
2 串的表示和实现
3 串的模式匹配算法
串，是由零个或多个字符组成的有限序列．
如: 'a string' 一般记为Ｓ＝’a1a2…an’ (n>=0) 其中Ｓ是串的名称，
用’’括起来的字符序列是串的值；
字符个数n称为串的长度．
零个字符的串称为空串用
来表示，长度为零．
来表示，长度为零． 由一个或多个空格组成的串称为空格串．
串中任意个连续的字符组成的子序列称为该串的子串．
包含子串的串相应地称为主串．
通常称字符在序列中的序号为该字符在串中的位置．
子串在主串中的位置则以子串的第一个字符在主串中的位置来表示．
例如： S ='abcaabcaaabc', T = 'bca'
串的逻辑结构和线性表极为相似，区别 仅在于串的数据对象约束为字符集。
串的基本操作和线性表有很大差别
在线性表的基本操作中，大多以“单个元素”作为操作对象；
在串的基本操作中，通常以“串的整体”作为操作对象。
4.1 串的抽象数据类型的定义如下：
ADT String {
数据对象：D＝{ ai |ai∈CharacterSet, i=1,2,...,n, n≥0 }
数据关系：R1＝{ < ai-1, ai > | ai-1, ai ∈D, i=2,...,n }
基本操作：
StrAssign (&T, chars)
DestroyString(&S)
StrCopy (&T, S)
StrLength(S)
StrCompare (S, T)
Concat (&T, S1, S2)
StrEmpty (S)
SubString (&Sub, S, pos, len)
ClearString (&S)
Index (S, T, pos)
Replace (&S, T, V)
StrInsert (&S, pos, T)
StrDelete (&S, pos, len)
} ADT String
StrAssign (&T, chars) 初始条件：chars 是字符串常量。 操作结果：把 chars 赋为 T 的值。
StrCopy (&T, S) 初始条件：串 S 存在。 操作结果：由串 S 复制得串 T
StrCompare(S,T) 初始条件： 串S和T存在。 操作结果： 若S> T，则返回值 > 0；若S < T，则返回值 < 0； 若S = T，则返回值 = 0。
例如：StrCompare('data', 'state') < 0 StrCompare('cat', 'case') > 0
StrLength(S) 初始条件：串 S 存在。 操作结果：返回 S 的元素个数， 称为串的长度。
Concat(&T,S1,S2) (concatenation) 初始条件：串 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(S)。
操作结果： 若主串 S 中存在和串 T 值相同的子串, 则返回它在主串 S 中第pos个字符之后第一次出现的位置；否则函数值为0。
Replace(&S,T,V) 初始条件：串S, T和 V 均已存在， 且 T 是非空串。
操作结果：用V替换主串S中出现 的所有与（模式串）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的子串。
ClearString(&S) 初始条件：串S存在。 操作结果：将S清为空串。
对于串的基本操作集可以有不同的定义方法，在使用高级程序设计语言中的串类型时，应以该语言的参考手册为准。
例如：C语言函数库中提供下列串处理函数：
gets(str) 输入一个串；
puts(str) 输出一个串；
strcat(str1, str2) 串联接函数；
strcpy(str1, str2, k) 串复制函数；
strcmp(str1, str2) 串比较函数；
strlen(str) 求串长函数；
在上述抽象数据类型定义的13种操作中，
串赋值StrAssign、串复制Strcopy、
串比较StrCompare、求串长StrLength、
串联接Concat以及求子串SubString 等六种操作构成串类型的最小操作子集。
即：这些操作不可能利用其他串操作来实现， 反之，其他串操作（除串清除ClearString和串 销毁DestroyString外）可在这个最小操作子 集上实现。
例如，可利用串比较、求串长和求子串等操作实现定位函数Index(S,T,pos)。
1 int Index (String S, String T, int pos) { 2 // T为非空串。若主串S中第pos个字符之后存在与 T相等的子串， 则返回第一个这样的子串在S中的位置，否则返回0 3 if (pos > 0) { 4 n = StrLength(S); m = StrLength(T); i = pos; 5 while ( i <= n-m+1) { 6 SubString (sub, S, i, m); 7 if (StrCompare(sub,T) != 0) ++i ; 8 else return i ; } // while 9 } // if return 0; // S中不存在与T相等的子串 10 } // Index
4.2 串的表示和实现
在程序设计语言中，串只是作为输入或输出的常量出现，则只需存储此串的串值，即字符序列即可。但在多数非数值处理的程序中，串也以变量的形式出现。
一、串的定长顺序存储表示
二、串的堆分配存储表示
三、串的块链存储表示
一、串的定长顺序存储表示
1 #define MAXSTRLEN 255
2 // 用户可在255以内定义最大串长
3 typedef unsigned char Sstring [MAXSTRLEN + 1];
4 // 0号单元存放串的长度
特点:
串的实际长度可在这个予定义长度的范围内随意设定，超过予定义长度的串值则被舍去，称之为 “截断” 。
按这种串的表示方法实现的串的运算时，其基本操作为 “字符序列的复制”。
1 int Index (String S, String T, int pos) {
2 // T为非空串。若主串S中第pos个字符之后存在与 T相等的子串，
3 则返回第一个这样的子串在S中的位置，否则返回0
4 if (pos > 0) {
5 n = StrLength(S); m = StrLength(T); i = pos;
6 while ( i <= n-m+1) {
7 SubString (sub, S, i, m);
8 if (StrCompare(sub,T) != 0) ++i ;
9 else return i ;
10 } // while
11 } // if return 0; // S中不存在与T相等的子串
12 } // Index
//串的联接算法中需分三种情况处理：
1 Status Concat(SString S1, SString S2, SString &T)
2 {// 用T返回由S1和S2联接而成的新串。若未截断, 则返回TRUE，否则FALSE。
3 if (S1[0]+S2[0] <= MAXSTRLEN) {// 未截断
4 T[1..S1[0]] = S1[1..S1[0]];
5 T[S1[0]+1..S1[0]+S2[0]] = S2[1..S2[0]];
6 T[0] = S1[0]+S2[0]; uncut = TRUE; }
7
8 else if (S1[0] <MAXSTRSIZE) { // 截断
9 T[1..S1[0]] = S1[1..S1[0]];
10 T[S1[0]+1..MAXSTRLEN] = S2[1..MAXSTRLEN－S1[0]];
11 T[0] = MAXSTRLEN; uncut = FALSE; }
12
13 else { // 截断(仅取S1)
14 T[0..MAXSTRLEN] = S1[0..MAXSTRLEN];
15 // T[0] == S1[0] == MAXSTRLEN
16 uncut = FALSE; }
17 }
二、串的堆分配存储表示
1 //串的堆分配存储表示
2 typedef struct {
3 char *ch;
4 // 若是非空串，则按串长分配存储区，
5 // 否则ch为NULL
6 int length; // 串长度
7 } HString;
通常，C语言中提供的串类型就是以这种存储方式实现的。
系统利用函数malloc( )和free( )进行串值空间的动态管理，为每一个新产生的串分配一个存储区，称串值共享的存储空间为“堆”。
C语言中的串以一个空字符为结束符， 串长是一个隐含值。
这类串操作实现的算法为： 先为新生成的串分配一个存储空间，然后 进行串值的复制。
1 Status Concat(HString &T, HString S1, HString S2)
2 { // 用T返回由S1和S2联接而成的新串
3 if (T.ch) free(T.ch); // 释放旧空间
4 if (!(T.ch = (char *)malloc((S1.length+S2.length)*sizeof(char))))
5 exit (OVERFLOW);
6 T.ch[0..S1.length-1] = S1.ch[0..S1.length-1];
7 T.length = S1.length + S2.length;
8 T.ch[S1.length..T.length-1] = S2.ch[0..S2.length-1];
9 return OK;
10 } // Concat
1 Status SubString(HString &Sub, HString S,int pos, int len)
2 { // 用Sub返回串S的第pos个字符起长度为len的子串
3 if (pos < 1 || pos > S.length || len < 0 || len > S.length-pos+1)
4 return ERROR;
5 if (Sub.ch) free (Sub.ch); // 释放旧空间
6 if (!len){ Sub.ch = NULL; Sub.length = 0; } // 空子串
7 else { Sub.ch = (char *)malloc(len*sizeof(char));
8 Sub.ch[0..len-1] = S[pos-1..pos+len-2];
9 Sub.length = len;
10 } // 完整子串
11 return OK;
12 } // SubString
三、串的块链存储表示
也可用链表来存储串值，由于串的数据元素是一个字符，它只有 8 位二进制数，因此用链表存储时，通常一个结点中存放的不是一个字符，而是一个子串。
存储密度小，运算处理方便，然而，存储量占用大。
1 #define CHUNKSIZE 80 // 块的大小 2 typedef struct Chunk { // 结点结构 3 char ch[CUNKSIZE]; 4 struct Chunk *next; 5 } Chunk; 6 typedef struct { // 串的链表结构 7 Chunk *head, *tail; // 串的头和尾指针 8 int curlen; // 串的当前长度 9 } LString;
实际应用时，可以根据问题所需来设置结点的大小
例如: 在编辑系统中，整个文本编辑区可以看成是一个串，每一行是一个子串，构成一个结点。即: 同一行的串用定长结构(80个字符), 行和行之间用指针相联接。
串值的链式存储结构对某些串操作如联接操作等有一定方便之处，但总的说来不如另外两种存储结构。
4.3 串的模式匹配算法
这是串的一种重要操作，很多 软件，若有“编辑”菜单项的话， 则其中必有“查找”子菜单项。
首先，回忆一下串匹配(查找)的定义:
INDEX (S, T, pos)
初始条件：串S和T存在，T是非空串，
1≤pos≤StrLength(S)。
操作结果：若主串S中存在和串T值相 同的子串，返回它在主串S中从第pos个字符开始第一次出现的位置；否则函数 返回值为0。
下面讨论以定长顺序结构表示串时的几种算法。
一、简单算法
二、首尾匹配算法
三、KMP(D.E.Knuth, V.R.Pratt, J.H.Morris) 算法
一、简单算法
1 int Index(SString S, SString T, int pos) {
2 // 返回子串T在主串S中第pos个字符之后的位置。若不存在，
3 // 则函数值为0。其中，T非空，1≤pos≤StrLength(S)。
4 i = pos; j = 1;
5 while (i <= S[0] && j <= T[0]) {
6 if (S[i] == T[j]) { ++i; ++j; } // 继续比较后继字符
7 else { i = i-j+2; j = 1; } // 指针后退重新开始匹配
8 }
9 if (j > T[0]) return i-T[0];
10 else return 0;
11 } // Index
12
13 while (i <= S[0] && j <= T[0])
14 { if (S[i] == T[j]) { ++i; ++j; } // 继续比较后继字符
15 else { i = i-j+2; j = 1; } // 指针后退重新开始匹配 }
i＝i的原位置＋1 ＝i－（j移动的长度）＋1
＝i－(j－1)＋1
＝i－j＋2
二、首尾匹配算法
先比较模式串的第一个字符， 再比较模式串的最后一个字符，
最后比较模式串中从第二个到 第n-1个字符。
1 int Index_FL(SString S, SString T, int pos) {
2 sLength = S[0]; tLength = T[0];
3 i = pos;
4 patStartChar = T[1]; patEndChar = T[tLength];
5 while (i <= sLength – tLength + 1) {
6 if (S[i] != patStartChar) ++i; //重新查找匹配起始点
7 else if (S[i+tLength-1] != patEndChar) ++i;
8 // 模式串的“尾字符”不匹配
9 else { k = 1; j = 2;
10 while ( j < tLength && S[i+k] == T[j])
11 { ++k; ++j; }
12 if ( j == tLength ) return i;
13 else ++i;
14 // 重新开始下一次的匹配检测
15 }
16 }
17 return 0;
18 }
一般情况下简单算法的时间复杂度为Ｏ(n+m)。但 主串为 `000000000000000000000000000000001` 模式串为`0000001`时，经常发生匹配到模式串的最后一个字符时，主串指针回溯的现象，导致用 简单算法时最坏情况下时间复杂度为Ｏ(n*m)。 改进后的算法思想是：主串指针不回溯，而将模式串滑到尽可能远的一段距离之后（即选择模式串中的某个字符）继续进行比较。 需要解决的问题是：失配时，主串中第i个字符与模式串中的哪个字符再比较
三、KMP(D.E.Knuth克努特, J.H.Morris 莫里斯 V.R.Pratt,普拉特) 算法
KMP算法的时间复杂度可以达到O(m+n)
需要解决的问题是：失配时，主串中第i个字符与模式串中的哪个字符再比较？
T[1..k-1] == T[j-k+1..j-1]成立
若令next[j]=k,则next[j]表明当模式串中第j个字符与主串中第i个字符失配时，在模式串中需重新和主串中该字符进行比较的字符的位置。
定义：模式串的next函数
int Index_KMP(SString S, SString T, int pos)
{ // 1≤pos≤StrLength(S)
i = pos; j = 1;
while (i <= S[0] && j <= T[0]) {
if (j = 0 || S[i] == T[j])
{ ++i; ++j; }
// 继续比较后继字符
else j = next[j]; // 模式串向右移动
}
if (j > T[0]) return i-T[0]; // 匹配成功
else return 0;
} // Index_KMP
厚积薄发，行胜于言@飞鸟各投林
