目录
1.SubString(SString* Sub, SString* S, int pos, int len);
2.StrCompare(SString* S, SString* T);
3.Index(SString* S, SString* T)
第四章 串
一、串
1.定义：
串，即字符串(String)是由零个或多个字符组成的有限序列。一般记为S = ‘a1a2......an’(n>=0)
其中S是串名，单引号括起来的字符串列是串的值：ai可以是字母、数字或其他字符；串中字符的个数n称为串的长度。n=0时的串称为空串（用Ф表示）。
例：
S = “HelloWorld!”
T = ‘iPhone 11 Pro Max?’
2.一些术语：
子串：串中任意个连续的字符组成的子序列。
Eg: ‘iPhone’ , ‘Pro M’是串T的子串
主串：包含子串的串。
Eg: T是子串’iPhone’的主串
字符串在主串的位置：字符在串中的序号。
Eg: ‘1’在T中的位置是8（第一次出现）
子串在主串中的位置：子串的第一个字符在主串中的位置。
Eg: ‘11 Pro’在T中的位置为8（注意：位序是从1开始，而不是从0开始）
空串 V.S 空格串：
M=’’ （M是空串）
N=’ ’（N是由3个空格字符组成的空格字符串，长度为3，每个空格字符占1B）
3.串V.S线性表
串是一种特殊的线性表，数据元素之间呈现线性关系
传的数据对象限定为字符集（如中文字符、英文字符、数字字符、标点字符等）
串的基本操作，如增删改查等通常以字符串为操作对象
4.基本操作
假设有串T=”” , S = “iPhone 11 Pro Max?” , W = “Pro”
StrAssign(&T,chars): 赋值操作。把串T赋值为chars.
StrCopy(&T,S): 复制操作。由串S复制到串T。
StrEmpty(S): 判空操作。若S为空串，则返回1，否则返回0.
StrLength(S): 求串长。返回串S的元素个数。
ClearString(&S): 清空操作。将S清为空串。
DestoryString(&S): 销毁串。将串S销毁（回收存储空间）。
Concat(&T,S1,S2): 串联接。用T返回由S1和S2联接而成的新串。
SubString(&Sub,S,pos,len): 求子串。用Sub返回串S的第pos个字符起长度为len的子串。
Index(S,T): 定位操作。若主串S中存在与串T值相同的子串，则
返回它在主串S中第一次出现的位置；否则函数值为0.
StrCompare(S,T): 比较操作。若S>T，则返回值>0；若S=T，则返回值=0；若S<T，则返回值<0。
Eg:执行基本操作Concat(&T,S,W) 后，T=”iPhone 11 Pro Max?Pro” （注意，要考虑存储空间是否要扩展）。
执行基本操作SubString(&T,S,4,6) 后，T=”one 11”
执行基本操作Index(S,W) 后，返回值为11
执行基本操作StrCompare(S,T) ，比较时，从第一个字符开始往后依次对比，先出现耿大夫的串就更大；长串的前缀与短传相同时，长串更大；只有两个串完全相同时，才相等。
5.字符集编码
任何数据存到计算机中一定是二进制数。需要确定一个字符和二进制数的对应规则这就是“编码”。
“字符集”：
英文字符 -- ASCII字符集
中英文 -- Unicode字符集
(基于同一个字符集，可以有多种编码方案，如：UTF-8，UTF-16)
Y =f (x) 字符集：函数定义域 编码：函数映射规则f y:对应的二进制数
注：采用不同的编码方式，每个字符所占空间不同，考研中只需默认每个字符占1B即可。
拓展：乱码的问题
在你的文件中，原本是采用某一套编码规则y = f(x)，如：‘码’↔0001010100010101010010
打开文件时，你的软件以为你采用的是另一套编码规则y=g(x)，如: 0001010100010101010010 ↔ 烫
二、串的存储方式
1.串的顺序存储
#define MAXLEN 255//预定义最大长度为255
typedef struct//静态数组实现（定长顺序存储）
{
char ch[MAXLEN];//每个分量存储一个字符
int length;//串的实际长度
}SString;typedef struct//动态数组实现（堆分配存储）
{
char* ch;//按串长分配存储区，ch指向的串的基地址
int length;//串的长度
}HString;
2.串的链式存储
typedef struct StringNode
{
char ch;//每个节点存1个字符
char ch[4];//每个结点存多个字符
struct StingNOde* next;
}StringNode,*String;char ch; 存储密度低：每个字符1B，每个指针4B
char ch[4]; 存储密度提高
3.基本操作实现（静态数组）
1.SubString(SString* Sub, SString* S, int pos, int len);
int SubString(SString* Sub, SString* S, int pos, int len)
{
if (pos + len - 1 > (*S).length)
{
return 0;
}
int i = 0;
for (i = pos; i < pos + len; i++)
{
(*Sub).ch[i - pos + 1] = (*S).ch[i];
}
(*Sub).length = len;
return 1;
}2.StrCompare(SString* S, SString* T);
int StrCompare(SString* S, SString* T)
{
int i = 0;
for (i = 1; i <= (*S).length && i<=(*T).length; i++)
{
if ((*S).ch != (*T).ch)
{
return (*S).ch - (*T).ch;
}
}
return (*S).length - (*T).length;
}3.Index(SString* S, SString* T)
int Index(SString* S, SString* T)
{
int i = 1;
int n = StrLength(*S);
int m = StrLength(*T);
SString sub;//用于暂存子串
while (i <= n - m - 1)
{
SubString(&sub, S, i, m);
if (StrCompare(&sub, T) != 0)
{
++i;
}
else
return i;//返回子串在主串中的位置
}
return 0;//S中不存在与T相等的子串
}三、模式匹配算法
字符串模式匹配：在主串中找到与模式串相同的子串，并返回其所在位置。
子串 — 主串的一部分，一定存在
模式串 — 不一定能在主串中找到
1.朴素模式匹配算法
主串长度为n，模式串长度为m
朴素模式匹配算法：将主串中所有长度为m的子串（最多对比n - m + 1个子串）依次与模式串对比，直到找到一个完全匹配的子串或所有的子串都不匹配为止。
Index(&S,&T):定位操作。若主串S中存在与串T 值相同的子串，则返回它在主串第一次出现的位置；否则函数值为0。
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;
}
}设主串长度为n，模式串长度为m，则最坏时间复杂度 = O(nm)
最坏的情况，每个子串都要对比m个字符，共n-m+1个子串，复杂度 = O((n-m+1)m) = O(nm)
注：很多时候，n>>m
2.Kmp算法
int Index_KMP(SString* S, SString* T,int next[])
{
int i = 1;
int 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;
}
}KMP算法，最坏时间复杂度O(n+m)
其中，求next数组时间复杂度O(m)
模式匹配过程最坏时间复杂度O(n)
3.求next数组
next数组的作用：当模式串的第j个字符失配时，从模式串的第next[j]的继续往后匹配
next1 :任何模式串都一样，第1个字符不匹配时，只能匹配下一个子串，因此，往后余生，next[1]都无脑写0
next[2]:任何模式串都一样，第2个字符不匹配时，应尝试匹配模式串的第1个字符，因此，往后余生，next[2]都无脑写1
next[3]在不匹配的位置前边，划一根美丽的界限模式串一步一步往后退，直到分界线之前“能对上”，或模式串完全跨过分界线为止
next[4,5,6]同理
4.KMP算法的进一步优化
手算解题：先求next数组，再由next数组求nextval数组
nextval[1] = 0;
for (int j = 2; j <= (*T).length; j++)
{
if ((*T).ch[next[j]] == (*T).ch[j])
{
nextval[j] = nextval[next[j]];
}
else
{
nextval[j] = next[j];
}
}
1018
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
