串

串string的定义

1，串是由零个或多个字符组成的有限序列，又名字符串。串中的字符数目n称为串的长度，零个字符的串称为空串（null string）。
2，空格串：只包含空格的串。注意其和空串的区别：空格串是有内容有长度的，而且可以不止一个空格
3，子串和主串：串中任意个数的连续字符组成的子序列称为该串的子串，相应的，包含子串的串称为主串。
子串在主串中的位置就是子串的第一个字符在主串中的序号。

串的比较

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

• ASCII编码：8位二进制表示一个字符，总共可以表示256个字符。
• Unicode编码，由16位二进制表示一个字符，约能表示65万多个字符。为了和ASCII码兼容，Unicode的前256个字符与ASCII码完全相同

两个串怎么样才算相等：长度相等，且各个对应位置的字符都相等。
两个串不相等时，如何判定大小：
给定两个串，ｓ＝“a1a2a3…an”, t = “b1b2b3…bm”,当满足以下条件之一时，s<t。

• n<m，且ai = bi（i=1,2,…,n）。
• 存在某个k≤min(m,n)，使得ai = bi(i=1,2,…,k-1)，ak<bk。

串的抽象数据类型

串针对的是字符集。线性表更关注的是单个元素的操作，比如查找一个元素，插入或删除一个元素，但串中更多的是查找子串位置，得到指定位置子串，替换子串等操作。

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；若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(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的子串。
endADT

例：操作Index的实现算法（使用基本操作的扩展函数完成）

//T为非空串。若主串S中存在和串T值相同的子串，则返回它在主串S中第pos个字符之后第一次出现的位置，否则返回0.
int Index（String S, String T, int pos）
{
	int n,m,i; 
	String sub;
	if (pos > 0)
	{
		n = StrLength(S); //得到主串长度
		m = StrLength(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;
}

其中用到了StrLength，SubString，StrCompare等基本操作来实现。

串的顺序存储结构

用一组地址连续的存储单元来存储串中的字符序列。有的语言规定在串值后面加一个不计入串长度的结束标记字符，比如“\0”来表示串值的终结。

这样有一个问题，就是对字符串进行操作时，都有可能使串序列的长度超过了数组的长度MaxSize。所以实际上串值得存储空间可在程序执行过程中动态分配而得，比如在计算机中存在一个自由存储区，叫做“堆”。这个堆可由C语言得动态分配函数malloc()和free()来管理。
ps：java中也有动态分配数组长度的设计，泛型ArrayList

串的链式存储结构

一个结点可以存放一个字符，也可以考虑存放多个字符，最后一个结点若是未被占满时，可以用“#”或其他非串值字符补全。

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

朴素的模式匹配算法

主串S，子串T，对主串的每一个字符作为子串开头，与要匹配的字符串进行匹配。对主串做大循环，每个字符开头做T的长度的小循环，直到匹配成功或全部遍历完成为止。
例：操作Index的实现算法（使用基本的数组实现）

//T为非空串。若主串S中存在和串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;
}

时间复杂度，n为主串长度，m为子串长度：

• 最好的情况如果一开始就匹配上，时间复杂度为O(1)
• 最后才匹配上，但每一次不匹配的情况从第一个字符开始就不匹配，时间复杂度为O(n+m)
• 最坏的情况，最后才匹配上，但每一次匹配不上的情况都是最后一个字符不匹配，时间复杂度为O[(n-m+1)*m]

KMP模式匹配算法

和朴素匹配算法最大的区别在于 i 不回溯，j根据字符重复的程度进行移动，j值的变化定义为一个数组next，next长度就是T串的长度

代码实现

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

//T为非空串。若主串S中存在和串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];
	get_next(T,next);                    
	while (i <= S[0] && j <= T[0])//若i小于S长度 且 j小于T的长度时循环
	{
		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;
}

时间复杂度：get_next函数的复杂度为O(m)，整个算法的时间复杂度为O(n+m)。

KMP模式匹配算法改进

//通过计算返回子串T的nextval数组
void get_nextval (String T, int *next)
{
	int i,j;
	i = 1;
	j = 0;
	nextval[1] = 0;
	while (i<T[0])//此处T[0]表示串T的长度
	{
		if (j==0 || T[i]==T[j]) //T[i]表示后缀的单个字符，T[j]表示前缀的单个字符
		{
			++i;
			++j;
			if (T[i] != T[j]) //若当前字符与前缀字符不同，则当前的j为nextval在i位置的值；如果与前缀字符相同，则将前缀字符的nextval值赋值给nextval在i位置的值
				nextval[i] = j;
			else
				nextval[i] = nextval[j];
		}
		else
			j = nextval[j]; //若字符不相同，则j值回溯
	}
}

实际匹配算法只要将get_next改成get_nextval即可。
总结改进过的KMP算法，它是在计算出next值的同时，如果a位字符与它next值指向的b位字符相等，则该a位的nextval就指向b位的nextval值。如果不等，该a位的nextval值就是它自己a位的next值。