大话数据结构笔记——第五章：串

串(string)是由零个或者多个字符串组成的有限序列，又叫字符串。

定义

串(string)是由零个或者多个字符串组成的有限序列，又叫字符串。一般记为s="$a_1$$a_2$……$a_n$"，s是串的名称，$a_i$（1<=i<=n），串中的字符数目n称为串的长度，零个字符的串称为空串(null string),子串与主串，串中任意个数的连续字符组成的子序列称为该串的子串，相应的包含子串的串称为主串。

串的比较

计算机中常用字符是使用标准的ACSII编码的，由8位二进制数表示一个字符，总共可以表示256个字符，由于256个字符不够，所以有了Unicode编码，常用由16位二进制表示一个字符，总共可以表示2¹⁶个字符，约是6.5万多个字符。为了兼容ASCII，Unicode前256个字符与ASCII码完全相同。
大小比较定义：
给定两个串：s="$a_1$$a_2$……$a_n$"，t="$b_1$$b_2$……$b_n$"，当满足以下条件之一时，s<t。

1. n<m，且$a_i$=$b_i$(i=1，2，……，n)。
2. 当存在某个k<=min(m,n)，使得$a_i$=$b_i$(i=1，2，……，k-1)，$a_k$<$b_k$。

串的抽象数据类型

ADT 串(string)
Data
	串中元素仅由一个字符组成，相邻元素具有前驱和后继关系
Operation.
	StrAssign(T,*chars):生成一个其值等于字符串常量chars的串T。
	StrCopy(T,S):串S存在，由串S复制得串T。
	ClearString(S):串S存在，将串清空。
	StringEmpty(S)：若串S为空，返回true，否则返回false。
	StrLength(S):返回串S得元素个数，即串的长度。
	StrCompare(S,T):根据S与T的大小关系，返回>0,=0,<0的值
	Concat(T,S1,S2):用T返回由S1和S2联结而成的新串。
	SubString(Sub,S,pos,len):用Sub返回串S的第pos个字符起长度为len的子串。
	Index(S,T,pos):若主串S中存在和串T值相同的子串，则返回它在主串S中第pos个
	字符之后第一次出现的位置，否则返回0
	Replace(S,T,V):串S,T,V存在，T是非空串。用V替换主串S中出现的所有与T相等的
	不重叠的子串。
	StrInsert(S,pos,T):在串S的第pos个字符之前插入串T
	StrDelete(S,pos,len):从串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)
	{
		n = StrLength(S); //得到主串S的长度
		m = StrLength(T); //得到子串T的长度
		i = pos;
		while(i <= n-m+1)
		{
			SubString(sub,S,i,m)//取主串的第i个位置
								//长度与T相等子串给sub
			if (StrCompare(sub,T)!=0) //如果两串不相等
			{
				++i;
			}
			else
				return i;
		}
	}
	return 0;//若无子串与T相等，返回0
}

串的存储结构

串的存储结构与线性表相同，分为两种

串的顺序存储结构

使用一组地址连续的存储单元来存储串中的字符序列。为串分配固定长度的存储区。在对字符串进行操作时（如：Concat,StrInsert等）都由可能使串序列的长度超过数组的长度MaxSize。所有串的顺序存储结构有一定的局限性。

串的链式存储结构

串的链式存储结构与线性表是相似的，但由于串结构的特殊性，结构中的每个元素数据是一个字符，如果也简单的应用链表存储串值，一个结点对应一个字符，就会存在很大的空间浪费。所以，一个结点可以考虑放多个字符，当最后一个结点如果没有被占满时，可以用“#”或其他非串值字符补全。串的链式存储结构除了在连接字符串与串操作时有一定方便外，总的来说不如顺序存储结构灵活，性能也不如顺寻存储结构好。

朴素的模式匹配算法

在主串中对子串的定位操作通常称做串的模式匹配。
**朴素模式匹配算法：**对每个主串的每一个字符作为子串开头，与要匹配的字符串进行匹配。对主串做大循环，每个字符开头做T的长度的小循环，直到匹配成功或全部遍历完成为止。
实现代码（区别与前面Index，不考虑用串的其他操作）：

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

这种匹配算法最坏情况的时间复杂度为O((n-m+1)*m)。

KMP模式匹配算法

这种算法可以大大避免重复遍历的情况，我们把它称之为KMP算法。

原理

在朴素的模式匹配算法中，主串的i值是不断回溯的来完成的，而KMP模式匹配算法就是为了让着没必要的回溯不发生，也就是不可以变小，所以要考虑就是j的值。把j值得变化定义为一个数组next，那么next的长度就是T串的长度。
于是得到下面的函数定义：

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

算法实现

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

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

若T的长度为m，因只涉及到简单的单循环，其时间复杂度为O(m)，而由于i值不回溯，while循环的时间复杂度为O(n)。因此整个算法的时间复杂度为O(n+m)。
这里需要注意的是，KMP算法仅当模式与主串之间存在许多“部分匹配”的情况下才体现出它的优势，否则两者的差异并不明显。

KMP模式匹配算法改进

子串中如果有元素连续相同，还可以再改进。
next改进算法代码：

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