《王道》数据结构之串（四）

---

概要

数据结构三要素——逻辑结构（定义）、数据的运算（基本操作）、存储结构（存储/物理结构不同，运算的实现方式不同）

---

一、串的概念和性质

1.1 串的概念

串，即字符串（String）是由零个或多个字符组成的有限序列。一般记为S = “a₁a₂······a_n”（n ≥0）。串中字符的个数n称为串的长度，n = 0时的串称为空串（用∅表示）。
区别空串""和空格串" "

术语	解释
子串	串中任意个连续的字符组成的子序列
主串	包含子串的串
字符/子串在主串中的位置	字符/子串的第一个字符 在主串中的位序（位序从1开始）

1.2 串的性质

• 串是一种特殊的线性表，数据元素之间呈线性关系
• 串的数据对象限定为字符集（如中文字符、英文字符、数字字符、标点字符等）

1.3 串的存储结构

1.3.1 顺序存储

顺序存储都是一个字符串数组+串长度,分为

• 静态数组实现（定长顺序存储）：栈区，数组长度不能改变
• 动态数组实现（堆分配存储）：堆区，数组长度可以改变
  
  该方案优点：字符的位序和数组下标相同

代码实现：

//静态数组实现：按预定义MAXLEN在栈区开辟存储区
#define MAXLEN 255
typedef struct{
	char ch[MAXLEN];
	int length;
}SString;

//动态数组实现：按串长在堆区开辟存储区，ch指向串的基地址，用完需手动delete指针
typedef struct{
	char *ch;	
	int length;
}HString;
HString S;
S.ch = new char[MAXLEN];		//用完需手动delete指针
S.length = 0;

1.3.2 链式存储

需遍历完才知道串长度

代码实现：

//结点结构和串结构：每个结点存多个字符
//（若每个结点存一个字符，则存储密度低：每个字符1B，每个指针4B）
typedef struct StringNode{
	char ch[4];
	struct StringNode* next;
}StringNode, *String;

二、串的基本操作

串的基本操作通常以子串为操作对象

2.1 创销赋清、增删改查

创销赋清	解释
创
DestroyString(&S)	销毁串：将串S销毁（回收存储空间）
StrAssign(&T,chars)	赋值操作：把串T赋值为chars
StrCopy(&T,S)	复制操作：由串S复制得到串T
ClearString(&S)	清空操作：将S清为空串

增删改查	解释
Concat(&T,S1,S2)	串联接：用T返回由S1和S2联接而成的新串
删
改
Index(S,T)	定位操作：若主串S中存在与串T值相同的子串，则返回它在主串S中第一次出现的位置；否则函数值为0
SubString(&Sub,S,pos,len)	求子串：用Sub返回串S的第pos个字符起长度为len的子串

//以下都是利用串的顺序存储结构实现的操作（下标为0的位置不存放字符串）

//1.求子串：用Sub存储串S的第pos个字符起长度为len的子串
bool SubString(SString &Sub, SString S, int pos, int len)
{
	//1.判断子串范围有没有越界
	if (pos+len-1 > S.length)		
	{
		return false;
	}
	
	//2.将子串赋给Sub
	for(int i = pos; i < pos+len ; i++)
	{
		Sub.ch[i-pos+1] = S.ch[i];
	}
	Sub.length = len;
	return true;
}

//2.定位操作：若主串S中存在与串T值相同的子串，则返回它在主串S中第一次出现的位置；否则函数值为0（该方法是最笨重的一种，优化见下一章KMP算法回溯）
int Index(SString S, SString T)
{	
	//1.准备
	SString sub;	//暂存返回的子串，用于比较

	//2.遍历寻找
	for(int i = 1; i <= StrLength(S)-StrLength(T)+1 ; i++)
	{
		SubString(sub,S,i,StrLength(T));
		if(StrCompare(sub,T) != 0)
		{
			i++;
		}
		else
		{
			return i;
		}
	}
	return 0;
}

2.2 其他操作

其他操作	解释
StrEmpty(S)	判空操作：若S为空串，则返回TRUE，否则返回FALSE
StrLength(S)	求串长：返回串S的元素个数
StrCompare(S,T)	比较操作：若S>T，则返回值>0；若S=T，则返回值=0；若S<T，则返回值<0
比较操作:从第一个字符开始往后依次对比，先出现更大字符的串就更大；若长串的前缀与短串相同时，长串更大（实质是任何数据包括字符存到计算机中一定是二进制数，比较字符大小其实是比较二进制数大小）

代码实现:

//1.比较操作：若S>T，则返回值>0；若S=T，则返回值=0；若S<T，则返回值<0。
int StrCompare(SString S, SString T)
{
	//1.先利用ch[i]比较：扫描字符当出现不同时即可完成比较
	for(int i = 1; i <= S.length && i <= T.length; i++)
	{
		if(S.ch[i] != T.ch[i])
		{
			return S.ch[i] - T.ch[i];
		}
	}
	
	//2.再利用length比较：扫描过的所有字符都相同时，则长度长的串更大
	return S.length - T.length;
}

三、字符串的模式匹配

字符串模式匹配：在主串中找到与模式串相同的子串，并返回其所在位置
区别：子串——主串的⼀部分，⼀定存在。 模式串——不⼀定能在主串中找到

3.1 朴素模式匹配算法

3.1.1 算法思想

朴素模式匹配算法：将主串中所有⻓度为m的⼦串依次与模式串对⽐，直到找到⼀个完全匹配的⼦串，或所有的⼦串都不匹配为⽌。
主串⻓度为n，模式串⻓度为 m，则最多对⽐ n-m+1 个⼦串

过程：
①若当前⼦串匹配失败，则主串指针 i 指向下⼀个⼦串的第⼀个位置，模式串指针 j 回到模式串的第⼀个位置

②若 j > T.length，则当前⼦串匹配成功，返回当前⼦串第⼀个字符的位置 —— i - T.length

缺点：
当某些子串与模式串能部分匹配时，主串的扫描指针i经常回溯，导致时间开销增加

3.1.2 代码实现与性能分析

代码实现：

int Index(SString S, SString T){
	//1.准备
	int i = 1, j = 1;
	
	//2.比较
	while(i <= S.length && j <= T.length)
	{
		//2.1 当前字符匹配成功：继续匹配
		if(S.ch[i] == T.ch[j])
		{
			++i;
			++j;
		}
		//2.2 当前字符匹配失败：指针后退重新开始匹配
		else	
		{
			i = i - j + 2;
			j = 1;
		}
	}

	//3.判断跳出循环的条件是哪个
	if(j > T.length)
		return i - T.length;
	else
		return 0;
}

时间复杂度：

• 最坏的情况，每个⼦串都要对⽐ m 个字符，共 n-m+1 个⼦串，复杂度 = O((n-m+1)m) = O(nm)
• 最好的情况，每个⼦串的第⼀个字符就匹配失败，共 n-m+1 个⼦串，复杂度 = O(n-m+1) = O(n)

3.2 KMP算法

3.2.1 算法思想

不匹配的字符之前，⼀定是和模式串⼀致的，即如果j=k才发现匹配失败，说明1~k-1都匹配成功。可以利用部分匹配成功的字符，确定模式串指针应该回溯到哪，主串指针是否要加1

过程：
①根据模式串T，求出 next 数组


②利⽤next数组进⾏匹配（主串指针不回溯）
注意：第一个元素匹配失败时，主串指针将要右移了，模式串指针回到1

3.2.2 代码实现与性能分析

代码实现：

int Index_KMP(SString S, SString T, int next[]){
	//1.准备
	int i=1, j=1;

	//2.比较
	while(i <= S.length && j <= T.length)
	{
		//2.1 当前字符匹配成功：主串、模式串指针都+1
		if(j==0 || S.ch[i] == T.ch[j])
		{
			++i;
			++j;
		}

		//2.2 当前字符匹配失败：模式串根据next数组偏移（主串指针i不回溯）
		else
		{
			j = next[j];
		}
	}

	//3.判断跳出循环的条件是哪个
	if(j > T.length)
		return i - T.length;
	else
		return 0;
}

时间复杂度：

• 最坏时间复杂度 O(m+n)
  求 next 数组时间复杂度 O(m)，模式匹配过程最坏时间复杂度 O(n)

3.2.3 算法优化（nextval数组）

即对next数组的优化：
①先算出next数组
②令nextval[1] = 0，然后

for(int j = 2; j <= T.length; ++j)
{
	if (T.ch[j] == T.ch[next[j])	//当前字符与next数组指向的下一个字符相同时
		nextval[j] = nextval[next[j]];
	else
		nextval[j] = next[j];
}

总结

代码附录