数据结构第四章 串

4.1_1_串的定义和基本操作

串，即字符串（String）是由零个或多个字符组成的有限序列。一般记为S=’a1a2……an’(n>=0)

其中，S是串名，单引号括起来的字符序列是串的值；ai可以是字母、数字或其他字符；穿中字符的个数n称为串的长度。n=0时的串称为空串

例：S=”HelloWorld!”

T=’iPhone 11 Pro Max?’

注：有的地方用双引号（如Java、C）有的地方用单引号（如Python）

子串：串中任意个连续的字符组成的子序列。

主串：包含子串的串。

字符在主串中的位置：字符在串中的序号。

子串在主串中的位置：子串在第一个字符在主串中的位置。

注意：位序从1开始，而不是从0开始

空串VS空格串

M=’’            N=’   ‘

M是空串，N是由三个空格字符组成的空格串

串是一种特殊的线性表，数据元素之间呈线性关系

串的数据对象限定为字符集（如中文字符、英文字符、数字字符、标点字符等）

串的基本操作，如增删改查通常以子串为操作对象

串的基本操作

StrAssign(&T,chars)：赋值操作。把串T赋值为chars。

StrCopy(&T,S)：复制操作。由串S复制得到串T。

StrEmpty(S)：判空操作。若S为空串，则返回TRUE，否则返回FALSE。

StrLength(S)：求串长。返回串S的元素个数。

ClearString(&S)：清空操作。将S清为空串。

DestroyString(&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，则返回值>；若S=T，则返回值=0；若S<T，则返回值<0。

从第一个字符开始往后依次对比，先出现更大字符的串就更大

长串的前缀与短串相同时，长串更大

只有两个串完全相同时，才相等

任何数据存到计算机中一定是二进制数。需要确定一个字符和二进制数的对应规则，这就是编码

4.1_2_串的存储结构

串的顺序存储

#define MAXLEN 255    //预定义最大串长为255 
typedef struct{
	char ch[MAXLEN];  //每个分量存储一个字符 
	int length;       //串的实际长度 
}SString;

静态数组实现（定长顺序存储）

typedef struct{
	char *ch;            //按串长分配存储区，ch指向串的基地址
	int length;          //串的长度 
}HString;
HString S;
S.ch=(char *) malloc(MAXLEN * sizeof(char));
S.length = 0;

动态数组实现（堆分配存储）

用malloc函数申请用完需要手动free

串的链式存储

typedef struct StringNode{
	char ch;         //每个结点存一个字符
	struct StringNode * next; 
}StringNode,* String;

存储密度低，每个字符1B，每个指针4B

typedef struct StringNode{
	char ch[4];        //每个结点存多个字符
	struct StringNode * next; 
}StringNode, * String;

存储密度提高

StrAssign(&T,chars)：赋值操作。把串T赋值为chars。

StrCopy(&T,S)：复制操作。由串S复制得到串T。

StrEmpty(S)：判空操作。若S为空串，则返回TRUE，否则返回FALSE。

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的子串。

//求子串 
bool SubString(SString &Sub, SString S, int pos, int len){
	//子串范围越界
	if(pos+len-1>S.length)
		return false;
	for(int i=pos; i<pos+len; i++)
		Sub.ch[i-pos+1]=S.ch[i];
	Sub.length=len;
	return false; 
}

StrCopare(S,T)：比较操作。若S>T，则返回值>0；若S=T，则返回值=0；若S<T，则返回值<0。

int StrCompare(SString S, SString T){
	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];
	}
	//扫描过的所有字符都相同，则长度长的串更大 
	return S.length-T.length;
}

Index(S,T)：定位操作。若主串S中存在与串T值相同的子串，则返回它在主串S中第一次出现的位置；否则函数值为0。

int Index(SString S, SString T){
	int i=1, n=StrLength(S), 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相等的子串 
}

4.2_1_朴素模式匹配算法

字符串模式匹配：在主串中找到与模式串相同的子串，并返回其所在位置

子串——主串的一部分，一定存在

模式串——不一定能在主串中找到

主串长度为n，模式串长度为m

朴素模式匹配算法：将主串中所有长度为m的子串依次与模式串对比，直到找到一个完全匹配的子串，或所有的子串都不匹配为止。

最多对比n-m+1个子串

int Index(SString S, SString T){
	int i=1, n=StrLength(S), 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相等的子串 
}

接下来：不适用字符串的基本操作，直接通过数组下标实现朴素模式匹配算法

若当前子串匹配失败，则主串指针i指向下一个子串的第一个位置，模式串指针j回到模式串的第一个位置

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

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(mn)

最坏的情况，每个子串都要对比m个字符，共n-m+1个子串，复杂度=O((n-m+1)m)=O(mn)

4.2_2_KMP算法（旧版上）

改进思路：主串指针不回溯，只有模式串指针回溯

int Index_KMP(SString S,SString T,int next[]){
	int i=1, 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; 
}

4.2_3_KMP算法（旧版下）

next数组：当模式串的第j个字符匹配失败时，令模式串跳到next[j]再继续匹配

串的前缀：包含第一个字符，且不包含最后一个字符的子串

串的后缀：包含最后一个字符，且不包含第一个字符的子串

当第j个字符匹配失败，由前1~j-1个字符组成的串记为S，则：next[j]=S的最长相等后缀长度加一

特别地，next[1]=0

模式串：’ababaa’

序号j	1	2	3	4	5	6
模式串	a	b	a	b	a	a
next[j]	0	1	1	2	3	4

KMP算法平均时间复杂度：O(n+m)

4.2_4_KMP算法的进一步优化

next[1]都无脑写0

next[2]都无脑写1

其他next：在不匹配的位置前，划一根美丽的分界线，模式串一步一步往后退，直到分界线之前“能对上”，或模式串完全跨过分界线为止。此时j指向哪儿，next数组值就是多少

求nextval数组

手算解题：先求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];
}