[08周课程]串相关代码

///顺序串
typedef struct
{
	char data[MaxSize];
	int length;
 } SqString;
 
 //生成串
 void StrAssign(SqString &s,char cstr[])
 {
 	int i;
 	for(i=0;cstr[i]!='\0';i++)
 	{
 		s->data[i] = cstr[i]; 
	 }
	 s.length = i;
  } 
  
  //销毁串
  void DestroyStr(SqString &s)
  {
  	
   }
   
   //串的复制
   void StrCopy(SqString &s,SqString t)
   {
   	int i;
   	for(i=0;i<t.length;i++)
   	{
   		s.data[i] = t.data[i];
	   }
	s.length = t.length;
	} 
	
	//判断串相等
	bool StrEqual(SqString s,SqString t)
	{
		if(s.length!=t.length)
			return false;
		int i;
		else
		{
			for(i=0;i<s.length;i++)
			{
				if(s.data[i]!=t.data)
				{
					return false
				}
			}
			return true;
		}
	 } 
	 
	 //求串长
	 
	 int StrLength(SqString s)
	 {
	 	return s.length;
	  } 
	  
	  //串连接
	  
	 SqString Concat (SqString s,SqString t)
	 {
	 	SqString str;
	 	int i;
	 	str.length = s.length + t.length;
	 	for(i=0;i<s.length;i++)
	 	{
	 		str.data[i] = s.data[i];
		 }
		 for(i=s.length;i<str.length;i++)
		 {
		 	str.data[i] = t.data[i];
		 }
		 return str;
	  } 
	  
	  //求子串
	  SqString SubStr(SqString s,int i,int j)
	  {
	  	int k;
	  	SqString str;
	  	str.length = 0;
	  	if(i<=0||i>s.length || j<0 || j>s.length)
  			return str;
		for(k=i-1;k<i+j-1;k++)
			str.data[k-i+1] = s.data[k];
		str.length = j;
		return str;
	   } 
	   //子串插入 
	  SqString InsStr(SqString s1,int i,SqString s2)
	  {
	  	int j;
	  	SqString str;
	  	str.length = 0;
	  	if(i<=0||i>s1.length+1)
	  		return str;
	  	for(j=0;j<i-1;j++)
	  		str.data[j] = s1.data[j];
	  	for(j=0;j<s2.length;j++)
	  		str.data[i+j-1] = s2.data[j];
	  	for(j=i-1;j<s1.length;j++)
	  		str.data[s2.length+j] = s1.data[j];
	  	str.length = s1.length + s2.length;
	  	return str;
	  }
	  //子串删除 
	  SqString DelStr(SqString s,int i,int j)
	  {
	  	int k;
	  	SqString str;
	  	str.length = 0;
	  	if(i<=0||i>s.length||i+j>s.length+1)
	  		return str;
	  	for(k=0;k<i-1;k++)
	  		str.data[k] = s.data[k];
	  	for(k = i+j-1;k<s.length;k++)
	  		str.data[k-j] = s.data[k];
	  	str.length = s.length - 1;
	  	return str;
	  }
	  //子串替换 
	  SqString RepStr(SqString s,int i,int j,SqString t)
	  {
	  	int k;
	  	SqString str;
	  	str.length = 0;
	  	if(i<=0;i>s.length || i+j-1>s.length)
	  		return str;
	  	for(k=0;k<i-1;k++)
	  		str.data[k] = s.data[k];
	  	for(k=0;k<t.length;k++)
	  		str.data[i+k-1] = t.data[k];
	  	for(k=i+j-1;k<s.length;k++)
	  		str.data[t.length+k-j] = s.data[k];
	  	str.length = s.length-j+t.length;
	  	return str;
	  }
	  
	  
	  /链串
	  typedef struct snode
	  {
	  	char data;
	  	struct snode *next;
	   } LinkStrNode;
	   //建立串 
	   void StrAssign(LinkStrNode *&s,char cstr[])
	   {
		int i;
		LinkStrNode *r,*p;
		s = (LinkStrNode *)malloc(sizeof(LinkStrNode));
		r = s;
		for(i=0;cstr!='\0';i++)
		{
			p = (LinkStrNode *)malloc(sizeof(LinkStrNode));
			p->data = cstr[i];
			r->next=p;
			r=p;
		}
		r->next = NULL;
		} 
		//销毁串 
		void Destroy(LinkStrNode *&s)
		{
			LinkStrNode *pre=s;*p=s->next;
			free(pre);
			while(p!=NULL)
			{
				free(pre);
				pre = p;
				p=pre->next;
			}
			free(pre);
		}
		//串的复制 
		void StrCopy(LinkStrNode *&s,LinkStrNode *t)
		{
			LinkStrNode *p=t->next,*q,*r;
			s = (LinkStrNode *)malloc(sizeof(LinkStrNode));
			r = s;
			while(p!=NULL)
			{
				q = (LinkStrNode *)malloc(sizeof(LinkStrNode));
				q->data = p->data;
				r->next = q;
				r=q;
				p=p->next;
			 } 
			 p->next = NULL;
		 } 
		 //判断串相等
		 bool StrEqual(LinkStrNode *s,LinkStrNode *t)
		 {
		 	LinkStrNode *p=s->next,*q=t->next;
		 	while(p!=NULL&&p!=NULL&&p->data==q->data)
		 	{
		 		p=p->next;
		 		q=q->next;
			 }
			if(p==NULL&&q==NULL)
				return true; 
			else
				return false; 
		}
		
		//求串长
		int StrLength(LinkStrNode *s)
		{
			int i=0;
			LinkStrNode *p=s->next;
			while(p!=NULL)
			{
				p=p->next;
				i++;
			}
			return i;
		 } 
		 
		 //串的连接
		 LinkStrNode *Concat(LinkStrNode *s,LinkStrNode *t)
		 {
		 	LinkStrNode *str,*p=s->next,*q,*r;
		 	str = (LinkStrNode *)malloc(sizeof(LinkStrNode));
		 	r = str;
		 	while(p!=NULL)
		 	{
		 		q = (LinkStrNode *)malloc(sizeof(LinkStrNode));
		 		q->data = p->data;
		 		r->next = q;
		 		r=q;
		 		p=p->next;
			 }
			 p=t->next;
			 while(p!=NULL)
			 {
			 	q = (LinkStrNode *)malloc (sizeof(LinkStrNode));
			 	q->data = p->data;
			 	r->next = q;
				r=q;
				p=p->next;  
			 }
			 r->next = NULL;
			 return r;
		  } 
		  //求子串 
		  LinkStrNode *SubStr(LinkStrNode *s,int i,int j)
		  {
		  	int k;
		  	LinkStrNode *str,*p=s->next,*q,*r;
		  	str = (LinkStrNode *)malloc(sizeof(LinkStrNode));
		  	str->next = NULL;
		  	r = str;
		  	if(i<=0||i>StrLength(s)||j<0||i+j-1>StrLength(s))
		  		return str;
		  	for(k=1;k<=j;k++)
		  	{
		  		q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
		  		q->data = p->data;
		  		r->next =q;
		  		r=q;
		  		p=p->next;
			  }
			  r->next = NULL;
			  return str;
		  }
		  
		  
		  
		  
		  //BF 
		  int BF(SqString s,SqString t)
		  {
		  	int i=0;
			int j=0;
		  	while(i<s.length&&j<t.length)
		  	{
		  		if(s.data[i]==t.data)
		  		{
		  			i++;
		  			j++
				}
				else
				{
				  	i=i-j+1;
				  	j=0;
				}
			  }
			  if(j>=t.length)
			  	return(i-j.length);
		  	  else
		  	  	return -1;
		  }