数据结构复习（四）—— 串

1. 串的顺序存储

#define MAXLEN 255			//预定义最大串长为255 
typedef struct
{
	char ch[MAXLEN];		//每个分量存储一个字符
	int length;			//串的实际长度 
}SString;		//定长顺序存储（静态数组实现）
 
typedef struct
{
	char *h;		//按串长分配存储区，ch指向串的基地址
	int length;		//串的长度 
}HString;		//堆分配存储（动态数组实现）

HString S;	
S.ch = (char *)malloc(MAXLEN * sizeof(char)); //用完需要手动free 
S.length = 0;

2. 串的链式存储

typedef struct StringNode
{
	char ch;		//每个结点存1个字符 
	struct StringNode *next;			
}StringNode,*String;	//存储密度低,每个字符1B，每个指针4B

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

3. 串的基本操作

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

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的子串。
StrCompare(S,T);		//比较操作。若S>T,返回值>0;若S=T,返回值=0;若S<T,返回值<0. 
//求子串
bool SubString(SString &Sub,SString S,int pos,int len) 
{
	//子串范围越界
	if(pos+len-1>S.length) //第0个位置没使用，所以是pos+len-1 
		return false;
	for(int i=pos;i<pos+len;i++)
		Sub.ch[i-pos+1]=S.ch[i];
	Sub.length=len;
	return true;
}

//比较操作。若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);	//n:主串长度,m:子串长度 
	SString sub;	//暂存子串
	while(i<=n-m+1)	//最多对比n-m+1个子串 
	{
		SubString(sub,S,i,m);	//sub<= S从i开始长度为 m的子串 
		if(StrCompare(sub,T)!=0)
			++i;
		else
			return i;	//返回子串在主串中的位置 
	} 
	return 0;	//S中不存在与T相等的子串 
}

4.串的模式匹配

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

//朴素模式匹配  匹配失败时，主串指针i疯狂回溯 
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)
//	最好时间复杂度 = O(n) 



//KMP算法-模式匹配  匹配失败时，主串指针i不回溯 
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
}
//	最坏时间复杂度 = O(m+n)；其中，求next数组时间复杂度O(m) 
//									模式匹配过程最坏时间复杂度 O(n) 

5. KMP算法

最坏时间复杂度 = O(m+n)；其中，求next数组时间复杂度O(m)

模式匹配过程最坏时间复杂度 O(n)

#define MAXLEN 255		//预定义最大串长为255 
typedef struct
{
	char ch[MAXLEN];	//每个分量存储一个字符
	int length;			//串的实际长度 
}SString;				//定长顺序存储（静态数组实现）
//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
}