数据结构--第四章

定义：
串：由零个或多个字符组成的有限序列。

1. 空串：∅ 长度为0
2. 子串：串中任意多个连续的字符组成的子序列(空串也是字符字串)
3. 主串：包含子串的串
4. 位置：某字符在串中的序号(从一开始)
5. 子串在主串中的位置： 子串的第一个字符在主串中的位置
6. 字符在主串中的位置： 字符在串中的序号

串的逻辑结构和线性表极为类似，数据元素之间呈现线性关系。

串的顺序存储

定长顺序存储

用一组连续的存储单元存储串值的字符序列。为每个串变量分配一个固定长度的存储区，既定长数组。

#define MAXLEN 255
typedef struct{
	char ch[MAXLEN];//定长静态数组
	int length;//串的实际长度
}SString;

1. 截断：串的实际长度超过MAXLEN，超过部分被舍弃。
2. 串长的表示方法：
   ①、用一个额外变量length来存放数组长度。
   

②、char[0]充当length
③、在串值后面加一个"\0"，此时串长是隐含的
④、char[0]废弃不用，另设length表示长度(①+②)

堆分配存储表示

仍然以一组连续的存储空间存放字符串值的字符序列，但存储空间是程序执行过程中动态分配到的。

typedef struct{
	char *ch;
	int length;
}HString;

//使用
HString S;
S.ch = (char*)malloc(MAXLEN*sizeof(char));
S.length = 0;

在C语言中，有一个称之为”堆“的自由存储区，通过malloch()和free()函数来完成管理。

串的链式存储(块链存储)

每个结点可以放一个或多个字符(填不满用"#"补上)。每个结点称为块，整个链表称为块链结构。

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

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

串基本操作的实现

#define MAXLEN 255
typedef struct{
	char ch[MAXLEN];//定长静态数组
	int length;//串的实际长度
}SString;

1. StrAssign(&T,chars)：赋值操作。把串T赋值为chars。
2. StrCopy(&T,S)：复制操作。由串S复制得到串T。
3. StrEmpty(S)：判空操作。若S为空串，则返回TRUE，否则返回FALSE。
4. StrLength(S)：求串长。返回串S的元素个数。
5. ClearString(&S)：清空操作。将S清为空串。
6. DestroyString(&S)：销毁串。将串S销毁（回收存储空间）。
7. Concat(&T,S1,S2)：串联接。用T返回由S1和S2联接而成的新串

8. SubString(&Sub,S,pos,len):用Sub返回串S的第pos个字符起长度为len的字串

bool SubString(SString &Sub,SString S,int pos,int len){//char[0]不存放数据
	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 true;
}

9. StrCompare(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;
}

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

int Index(SString S,SString T){
	int i=1,n = S.length,m = S.length;
	while(i<=n-m+1){
		SubString(sub,S,i,m);
		if(StrCompare(sub,T)!=0)i++;
		else return i;
	}
	return 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次，落在开始i的前一个，+2
			j=1;
		}
	}
	if(j>T.length) return i-T.length;//比完在加一，匹配成功j出来是T.length+1
	else return 0;
}

将主串中所以长度都为m的子串依次与模式串，直到找到一个完全匹配的字串或所有字串都不匹配位置。
最多匹配n-m+1个字串。

//设主串⻓度为 n，模式串⻓度为 m，n>>m
最坏时间复杂度 = O(nm)-->O((n-m+1)*m)
最好时间复杂度 = O(n)-->O(n-m+1)

KMP算法

用next数组匹配

next[j]含义：在子串的第j个字符与主串发生失配时，则跳到字串的next[j]位置重新和主串当前位置比较
利用next数组进行匹配(主串指针不回溯)

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;
}

KMP算法：最坏时间复杂度O(m+n)
求next数组时间复杂度：O(m)
模式匹配过程最坏时间复杂度:O(n)

求next数组(手算)

1. next[1]无脑写0，next[2]无脑写1
2. 其他：
   模式串一步一步往后退，直到分界线前面的能对上，或模式串全跨过分界线，此时next=j (第几个)