数据结构03--串（知识点加代码版）

一. 串的基本定义和基础操作

1. 串的定义

串，即字符串(String)是由零个或多个字符组成的有限序列。一般记为S=‘a102…0n’（n>=0)
其中，S是串名，单引号括起来的字符序列是串的值；a可以是字母、数字或其他字符；串中字符的个数n称为串的长度。n=0时的串称为空串（用0表示）。

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

主串：包含子串的串。

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

2.串的基本操作

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

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,则返回值>0：若S=T,则返回值=0：若S<T,则返回值<0。

3.字符集编码

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

二. 串的存储结构

1.串的顺序存储

//静态数组实现（定长顺序存储） 
typedef struct{
	char ch[MAXLEN];	//每个变量分储一个字符 
	int length;			//串的实际长度 
}SString; 

//动态数组实现（堆分配存储）
typedef struct{
	char *ch;
	int length;
}HString; 

void InitHString(HString &S)
{
	S.ch=(char *)malloc(MAXLEN*sizeof(char));
	S.length=0;
}

2.基本操作的实现

//求子串
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 ture;
} 

//比较。若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;
}

//定位
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;
} 

三. 字符串模式匹配

1.朴素模式匹配算法

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

//朴素模式匹配算法 
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; 
} 

最坏时间复杂度=O(nm)

2. KMP算法

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

next数组手算方法一：当第i个字符匹配失败，由前1~j-1个字符组成的串记为S,则：
next[j] = S的最长相等前后缀长度 + 1
特别地，next[1]=0,next[2]=1

next数组手算方法二

//求模式串T的next数组
void get_next(SString T,int next[]){
	int i=1;j=0;
	next[1]=0;
	while(i<T.length){
		if(j==0||T.ch[i]==T.ch[j]){
			++i;++j;
			//若pi=pj，则next[j+1]=next[j]+1
			next[i]=j; 
		}
		else
			j=next[j];//否则令j=next[j],循环继续。 
	}
} 

//模式匹配KMP，next[] 
int Index_KMP(SString S,SString T){
	int i=1;j=1;
	int next[T.length+1];
	get_next(T,next);
	while(i<=S.length&&j<=T.length){
		if(j==0||S.ch[i]==T.ch[i]){
			++i;
			++j;			//比较后继字符 
		}
		else
			j=next[j];		//模式串向右移动 
	}
	if(j>T.length)
		return i-T.length;	//匹配成功 
	else
		return 0;
}

最坏时间复杂度：（n+m）

3. KMP算法优化【优化next[]】

本质上是对next数组的优化。