四 . 串

一.串的定义与实现----图片

A.定义

B.存储方式

（1）顺序存储

方案一：返回字符位序从1开始，char[0]存储,返回不方便
方案二：char[0]只有1B=8bit,即共有0~255个数组，存储长度最多256，长度短
方案三：求长度只能！=’\0’遍历，时间复杂度高
方案四：char[0]无任何东西，定义length,较优解

a1.静态数组(优)

#define maxsize 255
typedef struct 
{
	char ch[maxsize];
	int length;	
}SString;

a2.动态数组

#define maxsize 255
typedef struct 
{
	char *ch;
	int length;	
}HString;



HString S;
S.ch =(char *)malloc(maxsize*sizeof(char));
S.length =0
 

（2）链式存储

b1.一个结点一个字符

typedef struct Stringnode
{
	char ch;                 //char占1个字节 
	struct Stringnode *next;//指针占4个字节	
}Stringnode,*String;

b2.一个结点多个字符

typedef struct Stringnode
{
	char ch[4];                 //char占4个字节 
	struct Stringnode *next;//指针占4个字节	
}Stringnode,*String;

C.基本操作----图片

（1）求子串SubString(SString &Sub,SString S,int pos,int len)+O(m子串长度)

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-1;i++)
	{
		Sub.ch [i-pos+1]=S.ch [i]; 
	}
	Sub.length =len;
	return true; 
}

（2）比较字符串StrCompare(SString S,SString T)

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];	
	}	
	//扫描过的所有字符都相等，长度长的串更大
	//eg:S:abcde     T:abcd 
	return S.length -T.length ;
}

（3）定位操作Index(SString S,SString T)

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）朴素模式(定位操作)

A.代码

1.好想到

int Index(SString S,SString T)
{
	int k=1;
	int i=k,j=1;
	while(i<=S.length&&j<=T.length )
	{
		if(S.ch [i]==T.ch [i])
		{
			++i;
			++j;
		}
		else 
		{
			k++;
			i=k;
			j=1; 
		}
	}
	//eg:S:wangdao  T:aoo     此时j->[o],i->[空，第八位]，而j<=T.length的 
	if(j>T.length )return k;
	else return 0;	
}

2.难想到（王道）

int Index(SString S,SString T)
{
	int i=1,j=1;
	while(i<=S.length&&j<=T.length )
	{
		if(S.ch [i]==T.ch [i])
		{
			++i;
			++j;
		}
		else 
		{
			i=i-j+2; 
			j=1; 
		}
	}
	//eg:S:wangdao  T:aoo     此时j->[o],i->[空，第八位]，而j<=T.length的 
	if(j>T.length )return i-T.length ;
	else return 0;	
}

B.时间复杂度O(nm)

n远大于m
模式串：m
主串：n
匹配成功 的最好时间复杂度：O(m)【即开始就匹配成功】
匹配失败 的最好时间复杂度：O(n-m+1)=O(n-m)=O(n)【因为指针回溯，直至最后一次匹配也失败，共匹配n-m+1次】

eg:
S:aaaaaaaaaaab
T:aaab
T每次比较4次，即m次
最多需要比较n-m+1次，即
直至匹配成功或失败最多需要(n-m+1)*m次,即O（nm)
1.最坏：每个子串的前m-1个字符与模式串匹配,只有第m个字符不匹配
2.比较好的情况：每个子串第一个字符就与模式串不匹配

（2）KMP (重点：手算next[],nextval[])—图片

A.KMP算法 + O(n+m)

//KMP算法
//S主串n， T模式串m
int Index_KMP(SString S,SString T)
{
	int i=1,j=1,next[T.length+1];
	get_next(T,next);//求next===O(m)
	while(i<=S.length&&j<=T.length )//====O(n)
	{
		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;
}

B.求next[] + O(m)

//求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];
		}
	}
}

C. 求nextval[]

优化：子串和模式串不匹配时，j=nextval[j];

解决的问题是，当char[j]!=char[i]时，进行j=next[j],此时若char[j]==char[next[j]],则char[next[j]]==char[i],则是继续j=next[j]…，
即char[j]==char[next[j]]时进行优化，直接让j=next[j]=next[next[j]],即可实现nextval数组

第一步求出next[]
第二部求nextval[]

//求nextval[]
//T是模式串
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]; 
}