数据结构之串

串的堆分配表示

#include<stdio.h>
#include<stdlib.h>
#include<string.h>


typedef struct{
	char *ch;
	int length;
}HString;

/* 初始化(产生空串)字符串T。另加 */
void InitString(HString *T)
{ 
	(*T).length=0;
	(*T).ch=NULL;
}

/* 生成一个其值等于串常量chars的串T */
int StrAssign(HString *T,char *chars)
{ 
	int i,j;
	if((*T).ch)
		free((*T).ch); /* 释放T原有空间 */
	i=strlen(chars); /* 求chars的长度i */
	if(!i)
	{ /* chars的长度为0 */
		(*T).ch=NULL;
		(*T).length=0;
	}
	else
	{ /* chars的长度不为0 */
		(*T).ch=(char*)malloc(i*sizeof(char)); /* 分配串空间 */
		if(!(*T).ch) /* 分配串空间失败 */
			exit(1);
		for(j=0;j<i;j++) /* 拷贝串 */
			(*T).ch[j]=chars[j];
		(*T).length=i;
	}
	return 1;
}

/* 初始条件:串S存在。操作结果: 由串S复制得串T */
int StrCopy(HString *T,HString S)
{
	if(T->ch)
		free(T->ch);
	T->length=S.length;
	T->ch=(char *)malloc(T->length*sizeof(char));
	int i;
	for(i=0;i<T->length;i++)
		T->ch[i]=S.ch[i];
	return 1;

}
void StrPrint(HString T)
{ /* 输出T字符串。另加 */
	int i;
	for(i=0;i<T.length;i++)
		printf("%c",T.ch[i]);
	printf("\n");
}

/* 初始条件: 串S存在。操作结果: 若S为空串,则返回TRUE,否则返回FALSE */
int StrEmpty(HString S)
{
	if(S.length==0 && S.ch==NULL)
		return 1;
	return 0;
}
/* 若S>T,则返回值>0;若S=T,则返回值=0;若S<T,则返回值<0 */
int StrCompare(HString S,HString T)
{
	int i;
	for(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;
}

/* 返回S的元素个数,称为串的长度 */
int StrLength(HString S)
{ 
   return S.length;
}

int ClearString(HString *S)
{ /* 将S清为空串 */
   if((*S).ch)
   {
     free((*S).ch);
     (*S).ch=NULL;
   }
   (*S).length=0;
   return 1;
 }
 /* 用T返回由S1和S2联接而成的新串 */
int Concat(HString *T,HString S1,HString S2)
{
	if(T->ch)
		free(T->ch);
	T->ch=(char *)malloc((S1.length+S2.length)*sizeof(char));
	int i;
	for(i=0;i!=S1.length;i++)
		T->ch[i]=S1.ch[i];
	for(i=S1.length;i!=S1.length+S2.length;i++)
		T->ch[i]=S2.ch[i-S1.length];
	T->length=S1.length+S2.length;
	return 1;
}
/* 用Sub返回串S的第pos个字符起长度为len的子串。 */
   /* 其中,1≤pos≤StrLength(S)且0≤len≤StrLength(S)-pos+1 */
int SubString(HString *Sub, HString S,int pos,int len)
{
   int i;
   if(pos<1||pos>S.length||len<0||len>S.length-pos+1)
	   return 0;
   if(Sub->ch)
	   free(Sub->ch);
   if(!len) /* 空子串 */
   {
		(*Sub).ch=NULL;
		(*Sub).length=0;
   }else{
	   /* 完整子串 */
		Sub->ch=(char *)malloc(len*sizeof(char));
		for(i=pos-1;i!=pos+len-1;i++)
			Sub->ch[i-pos+1]=S.ch[i];   
		 Sub->length=len;
   }
   return 1;
}

/* T为非空串。若主串S中第pos个字符之后存在与T相等的子串, */
/* 则返回第一个这样的子串在S中的位置,否则返回0 */
int Index(HString S,HString T,int pos) /* 算法4.1 */
{
	int n,m,i;
	HString sub;
	InitString(&sub);
	if(pos>0)
	{
		n=StrLength(S);
		m=StrLength(T);
		i=pos;
		while(i<=n-m+1)
		{
			SubString(&sub,S,i,m);
			if(StrCompare(sub,T)!=0)
				++i;
			else
				return i;
		}
	}
   return 0;
}

/* 1≤pos≤StrLength(S)+1。在串S的第pos个字符之前插入串T */
int StrInsert(HString *S,int pos,HString T) /* 算法4.4 */
{ 
   int i;
   if(pos<1||pos>(*S).length+1) /* pos不合法 */
	   return 0;
   if(T.length) /* T非空,则重新分配空间,插入T */
   {
	   (*S).ch=(char*)realloc((*S).ch,((*S).length+T.length)*sizeof(char));
	   if(!(*S).ch)
		   exit(1);
	   for(i=(*S).length-1;i>=pos-1;--i) /* 为插入T而腾出位置 */
		   (*S).ch[i+T.length]=(*S).ch[i];
	   for(i=0;i<T.length;i++)
		   (*S).ch[pos-1+i]=T.ch[i]; /* 插入T */
	   (*S).length+=T.length;
   }
   return 1;
 }

/* 从串S中删除第pos个字符起长度为len的子串 */
int StrDelete(HString *S,int pos,int len)
{ 
	if(pos<1 || pos>S->length || pos+len-1>S->length)
		return 0;
	int i;
	for(i=pos+len-1;i!=S->length;i++)
		S->ch[i-len]=S->ch[i];
	(*S).length-=len;
	(*S).ch=(char*)realloc((*S).ch,(*S).length*sizeof(char));
	return 1;
}

/* 初始条件: 串S,T和V存在,T是非空串（此函数与串的存储结构无关） */
/* 操作结果: 用V替换主串S中出现的所有与T相等的不重叠的子串 */
int Replace(HString *S,HString T,HString V)
{
	int i=1;
	if(StrEmpty(T))
		return 0;
	do{
		i=Index(*S,T,i);
		if(i)
		{
			StrDelete(S,i,T.length);
			StrInsert(S,i,V);
			i=i+V.length;
		}
	}while(i);
	return 1;
}
int main(){
	HString s1;
	InitString(&s1);
	StrAssign(&s1,"Hello World");
	StrPrint(s1);

	HString s2;
	InitString(&s2);
	StrAssign(&s2,"prince");
	StrPrint(s2);

	StrCopy(&s1,s2);
	StrPrint(s1);

	//printf("%d\n",StrCompare(s1,s2));
	HString s3;
	InitString(&s3);
	Concat(&s3,s1,s2);
	StrPrint(s3);

	//SubString(&s1,s3,5,3);
	//StrPrint(s1);
//	StrDelete(&s3,5,3);
//	StrPrint(s3);

	StrAssign(&s1,"in");
	StrAssign(&s2,"++");
	Replace(&s3,s1,s2);
	StrPrint(s3);
	return 0;
}

串的块链存储表示