字符串的一些问题———关键是KMP算法

/*动态顺序串*/
#include <iostream>
using namespace std;
/*动态顺序串的定义*/
typedef struct DString
{
	char *ch;
    int length;
}DString;
/*初始化动态串*/
void initString(DString &S)
{
	S.ch=new char[100];
	S.length=0;
}
/*串常量的长度*/
int lenString(char chars[])
{
	int len=0;
	int i=0;
    while(chars[i]!='/0')
	{
        len++;
		i++;
	}
    return len;
}
 
/*串赋值*/
void strEval_Sq(DString &S,char chars[])
{
	int lenStr;
	if(S.ch)
		delete S.ch;//若串已存在，则释放s的空间。
    lenStr=lenString(chars);
    if(lenStr==0)
	{
		S.ch=NULL;
		S.length=0;
	}
	else
	{
		S.ch=new char[lenStr];
		int i=0;
		while(chars[i]!='/0')
		{
			S.ch[i]=chars[i];
			i++;
		}
		S.length=lenStr;
	}
}
/*销毁串*/
void destroyStr(DString &S)
{
	delete S.ch;
	S.length=0;
}
 
/*串连接*/
void concatStr(DString &S,DString T)//将串T连接到串S的后面，需要一个临时数组。
{
	DString temp;
	if(T.length!=0)
	{
		temp.ch=new char[S.length+T.length];//构造一个临时的串
		int i=0,j=0;
		for(i;i<S.length;i++,j++)
			temp.ch[j]=S.ch[i];//将串S复制到temp中
		i=0;
		for(i;i<T.length;i++,j++)
			temp.ch[j]=T.ch[i];//将串T复制到temp中
		S.ch=temp.ch;
		S.length=S.length+T.length;
		delete []temp.ch;
	}
}
/*求从某个位置开始，特定长度的子串*/
void strSub_Sq(DString &Sub,DString S,int i,int len)
{
	if(i<1||i>S.length||len<0||len>S.length-i+1)
		cout<<"Parameters Error!";
	if(Sub.ch)
		delete Sub.ch;//若串已存在，释放其空间
	if(len==0)
	{
		Sub.ch=NULL;
		Sub.length=0;
	}//以上三个if是考虑特殊情况。
	else
	{
		Sub.ch=new char[len];
		for(int j=0;j<len;j++)
			Sub.ch[j]=S.ch[i-1+j];
		Sub.length=len;
    }
}
/*串比较*/
int cmpStr_Sq(DString S,DString T)
{
	for(int i=0;(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);//字符相同，但长度不同的情况。
}

/*取主串中和模式串匹配的子串的首地址*/
//简单的模式串匹配，BF算法
int strIndex_BF(DString &S,DString &T)
{
	int i=1;
	int j=1;
	while(i<=S.length-T.length+1  &&  j<=T.length)
	{
		if(S.ch[i]==T.ch[j] || j==0)
		{
			i++;
			j++;
		}
		else
		{
			i=i-j+2;//i回溯到这次比较的起始位置的下一个位置。
			j=1;//j回溯到起始位置。
		}
	}
	if(j>T.length)
		return (i-j+1);
	else
		return 0;
}

//next的第一种算法	
int* getNext_1(DString T)
{
	int *next=new int[T.length];
	int j=1;
	int k=0;
	next[j]=0;//设置初始值。
	while(j<T.length)
	{
		if(k==0||T.ch[j]==T.ch[k])
		{
			j++;
			k++;
			next[j]=k;
		}
		else
			k=next[k];
	}
	return next;
}
//next的第二种算法	
int* getNext_2(DString T)//将模式串也看成两个相同的主串和模式串来求next[]
{
	int *next=new int[T.length];
	int j=1;//j表示的是数组next的下标
	int k=0;//k为next[j]的值
	next[j]=k;//设置初始值。
	while(j<T.length)
	{
		if(k==0||T.ch[j]==T.ch[k])//若k==0，即next[j]==k==0，则不论T.ch[j]和T.ch[k]是否相等都要向后移一位
		{
			j++;
			k++;
			if(T.ch[j]!=T.ch[k])//如果T.ch[j]和T.ch[k]相等，则T.ch[k]也会和主串中的字符不匹配，那就不需要做这一次比较了
				next[j]=k;
			else
				next[j]=next[k];//直接让next[j]等于next[k]就可以了
		}
		else
			k=next[k];//如果不相等的话，那么让k指针回溯，一直回溯到下一个相等的地方。
	}
	return next;
}

//改进的模式串匹配，KMP算法
int strIndex_KMP(DString &S,DString &T)
{
	int* next=getNext_2(T);
	int i=1;
	int j=1;
	while(i<=S.length-T.length+1  &&  j<=T.length)
	{
		if(j==0 || S.ch[i]==T.ch[j])
		{
			i++;
			j++;
		}
		else
			j=next[j];
	}
	if(j>T.length)
		return i-j+1;
	else
		return 0;
}
/*创建动态顺序串*/
void creatString(DString &S,int n)
{
	int i;
	
	for(i=1;i<=n;i++)
	{
		cin>>S.ch[i];
		S.length++;
	}
}
/*输出动态串*/
void outputString(DString &S)
{
	int i;
	for(i=1;i<=S.length;i++)
	{
		cout<<S.ch[i];
	}
	cout<<endl;
}

void main()
{
	freopen("in.txt","r",stdin);
	DString T;
	DString S;
	initString(S);
	initString(T);
	creatString(S,26);
	creatString(T,3);
	
	//creatString(T,12);
	
	//concatStr(S,T);
	//
	outputString(S);
	outputString(T);
	cout<<strIndex_BF(S,T)<<endl;
	cout<<strIndex_KMP(S,T)<<endl;
	
}