数据结构(C语言版)----------串的堆分配C语言实现

实现代码

#include <stdio.h>//printf();scanf() 
#include <stdlib.h>//exit();malloc()
//函数结束状态代码 
#define OVERFLOW -1
#define OK 1
#define TRUE 1
#define ERROR 0
//Status是函数的类型，其值是函数结果状态代码 
typedef int Status;
//串的堆分配存储表示 
typedef struct
{
	char *ch;//若是非空串，则按串长分配存储区，否则ch为NULL 
 	int length;//串长度 
}SString;
//操作结果:初始化生成一个空串S 
Status StrInit(SString &S){
	S.ch=(char*)malloc(sizeof(char));
 	if(!S.ch) return ERROR;//分配存储空间失败
 	S.ch=NULL;
 	S.length=0;//串长为0
 	return OK;
}
//初始条件:chars是字符串常量 
//操作结果:生成一个其值等于串常量chars的串S
int StrAssign(SString &S,char *chars){
	int i;
//	if(T.ch)free(T.ch);					//释放T原有空间 【1】 
	char *c=chars;
	for(i=0;*c!='\0';++i,++c);		//求chars的长度i
	if(!i){
		S.ch=NULL;
		S.length=0;
	}else{
		if(!(S.ch=(char*)malloc(i*sizeof(char))))return 0;	//分配空间的同时判断是否成功分配 
		for(int j=0;j<i;j++)
			S.ch[j]=chars[j];
		S.length=i;
	}
	
	return 1;
}
// 初始条件：串S存在。
// 操作结果：由串S复制得串T
Status StrCopy(SString &T,SString S){
	if(T.ch) free(T.ch);
	if(!(T.ch=(char*)malloc(S.length*sizeof(char)))){ 
		printf("存储空间分配失败!\n");
		exit(OVERFLOW);
	} 
	for(int i=0; i<=S.length; i++)
		T.ch[i]=S.ch[i];
	T.length=S.length;
	return OK; 
}
//初始条件:串T存在
//操作结果:返回S的元素个数，称为串的长度 
Status StrLength(SString S){
	return S.length;
}
// 初始条件：串T存在。
// 操作结果：若T为空串，则返回TRUE；否则返回FALSE。
Status StrEmpty(SString S){
	return S.length==0?TRUE:ERROR;
} 
// 初始条件：串S和T存在。
// 操作结果：若S>T，则返回值>0；若S=T，则返回值=0；若S<T，则返回值<0。
Status StrCompare(SString S,SString 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存在。
// 操作结果：将S清为空串。
Status ClearString(SString &S){
	if(S.ch){
		free(S.ch);
		S.ch=NULL;
	}
	S.length=0;
	return 0;
} 
// 初始条件：串S1和S2存在。
// 操作结果：用T返回S1和S2联接而成的新串。
Status Concat(SString &T,SString S1,SString S2){
	int i,j;
	if(T.ch) free(T.ch);//释放旧空间 
	if(!(T.ch=(char*)malloc((S1.length+S2.length)*sizeof(char))))
		exit(OVERFLOW); 
	for(i=0;i<S1.length;i++){
		T.ch[i]=S1.ch[i];
	}
	T.length=S1.length+S2.length;
	for(i=0;i<S2.length;i++){
	  T.ch[i+S1.length]=S2.ch[i];
	}
	return OK;
}
// 初始条件：串S存在，1≤pos≤StrLength(S)且0≤len≤StrLength(S)-pos+1。
// 操作结果：用Sub返回串S的第pos个字符起长度为len的子串。
Status SubString(SString &Sub,SString S,int pos,int len){
	int i,j=0;
 	if(pos<1||pos>S.length||len<0||len>S.length-pos+1){
  		printf("参数不合法!\n");
  		return ERROR;
 	}
 	if(Sub.ch) free(Sub.ch);//释放旧空间
	if(!len) {
		Sub.ch=NULL;
		Sub.length=0;//空字串
		printf("空子串!\n"); 
	} 
 	else{//完整子串 
 		Sub.ch=(char*)malloc(len*sizeof(char));	
 		for(i=0;i<len;i++)
 			Sub.ch[i]=S.ch[pos-1+i];
 		Sub.length=len;
	}
 	return OK;
}
// 初始条件：串S和T存在，T就非空串，1≤pos≤StrLength(S)。
// 操作结果：若主串S中存在和串T值相同的子串，则返回它在主串S中第pos个字符之后第一次出现的位置; 否则函数值为0。
Status Index(SString S,SString T,int pos){
	int i=pos-1,j=0;
	if(pos<1||pos>S.length){
		printf("参数不合法!\n");
		return ERROR;
	}
	while(i<S.length&&j<T.length){
		if(S.ch[i]==T.ch[j]){
			++i;
			++j;
		}
		else{
			i=i-j+1;
			j=0;
		}
	}
	if(j>=T.length)
		return i-T.length+1;
	else 
		return 0;
}
// 初始条件：串S和T存在，1≤pos≤StrLength(S)+1。
// 操作结果：在串S的第pos个字符之前插入串T。
Status StrInsert (SString &S,int pos,SString T){
	int i,j;
 	if(pos<1||pos>S.length+1){//pos不合法
  		printf("the pos is a wrong valuen");
  	return ERROR;
 	}
	if(T.length){//T非空，则重新分配空间，插入T 
		if(!(S.ch=(char*)realloc(S.ch,(S.length+T.length)*sizeof(char))))
			exit(OVERFLOW);
		for(i=S.length-1;i>=pos-1;--i)//为插入T而腾出位置 
  			S.ch[i+T.length]=S.ch[i];
  		for(i=pos-1,j=0;i<=pos+T.length-2;i++,j++)
		  	S.ch[i]=T.ch[j];
		S.length+=T.length;	
 	}
 	return OK;
}
// 初始条件：串S存在，1≤pos≤StrLength(S)-len+1。
// 操作结果：从串S中删除第pos个字符起长度为len的子串。
Status StrDelete(SString &S,int pos,int len){
	int i;
	if(pos<1||pos>S.length||len<0||len>S.length-pos+1){
		printf("参数不合法!\n");
	  	return ERROR;
	}
	for(i=pos+len-1;i<S.length;i++)
		S.ch[i-len]=S.ch[i];
	S.length-=len;
	return OK;
}
// 初始条件：串S，T和V存在，T是非空串。
// 操作结果：用V替换主串S中出现的所有与T相等的不重叠的子串。
Status Replace(SString &S,SString T,SString V){
	int i=1;
	do{
		i=Index(S,T,i);
		if(i){
			StrDelete(S,i,StrLength(T));
			StrInsert(S,i,V);
		}
	}while(i);
	return OK;
}
void StrDestory(){
	//堆分配的字符串无法销毁 
}
//操作结果:输出字符串T。
void StrPrint(SString S) {
	for( int i = 0; i<S.length; i++)
		printf("%c ", S.ch[i]);
	printf("\n");
}

int main()
{
	SString S,S2,T,Sub;
	char s1[100];
	char s2[100];
	scanf("%s%s",s1,s2);
	int pos,len;
 	StrInit(S);
 	StrInit(S2);
 	StrInit(T);
 	StrInit(Sub);
 	printf("为字符串S和S2赋初值并打印!\n");
 	StrAssign(S,s1);
 	StrAssign(S2,s2);
 	StrPrint(S);
 	StrPrint(S2);
 	printf("由字符串S复制得字符串T!\n");
 	StrCopy(T,S); 
 	printf("字符串T为:");
 	StrPrint(T);
	printf("the length of the string S is %d .\n",StrLength(S));
	printf("比较字符串的大小!\n");
    if(StrCompare(S,S2)>0) 
  		printf("S>S2\n");
 	else if(StrCompare(S,S2)==0)
   		printf("S=S2\n");
  	else
   		printf("S<S2\n");
 	printf("将串S，S2合并得串T!\n");
 	Concat(T,S,S2);
 	printf("字符串T为:");
 	StrPrint(T);
 	printf("取出字符串S第pos个字符起长为len的子串!\n");
 	printf("pos=");scanf("%d",&pos);printf("len=");scanf("%d",&len);
 	SubString(Sub,S,pos,len);
 	printf("子串Sub为:");
 	StrPrint(Sub);
 	printf("pos=");scanf("%d",&pos);
 	printf("返回子串Sub在主串S中第%d个字符之后第一次出现的位置",pos);
	printf("%d\n",Index(S,Sub,pos));	
 	printf("在字符串S的第pos个位置之前插入字符串S2!\n");
 	printf("pos=");
	scanf("%d",&pos);
 	StrInsert(S,pos,S2);
 	printf("字符串S为:");
	StrPrint(S);	
 	printf("删除字符串S第pos个字符起长为len的字符串!\n");
 	printf("pos=");scanf("%d",&pos);printf("len=");scanf("%d",&len);
 	StrDelete(S,pos,len);
 	printf("字符串S为:");
 	StrPrint(S);
 	printf("字符串的替换!\n");
 	Replace(S,Sub,S2);
 	printf("输出字符串S:");![在这里插入图片描述](https://img-
	StrPrint(S); 
 	printf("字符串S?1为空:0不为空  %d\n",StrEmpty(S));
 	ClearString(S);
 	printf("ClearString之后字符串S?1为空:0不为空  %d\n",StrEmpty(S));
 	return 0;
}

运行结果

`