数据结构串的基本操作

数据结构串的堆分配的基本操作

函数

//初始化字符串
Status InitString(HString &T)
//生成一个其值等于串常量 chars 的字符串 T
Status StrAssign(HString &T,char *chars)
//返回字符串元素的个数
Status StrLength(HString S)
//比较字符串长度
Status StrCompare(HString S,HString T)
//清空S串
void ClearString(HString S,HString T)
//输出字符串
Status printStr(HString S)
//连接S1和S2生成的新串S
HString ConcatString(HString &S,HString S1,HString S2)
//用Sub返回串S的第pos 个字符起长度为len的子串
Status SubString(HString Sub,HString S,int pos,int len)
//返回主串S中子串T的位置
int Index(HString S,HString T,int pos)
//在主串S的第pos位置插入子串T
HString StrInsert(HString S,int pos,HString T)
// 从串S中删除第pos个字符起长度为len的子串
HString StrDelete(HString S,int pos,int len)
//用V替换主串S中出现与Str相等的子串 
Status Replace(HString S,HString T,HString V)

直接放代码：

/*
	作者: YJY
	时间: 2021-5-13
*/

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

#define OVERFLOW -1
#define OK 1
#define ERROR 0
 
typedef int Status ;
typedef struct{
	char *ch;
	int length;
}HString;

//初始化字符串
Status InitString(HString &T){
	T.ch=NULL;           //指针指向NULL,长度为0即可
	T.length=0;          //p.s.申请内存空间的过程在赋值中完成
	return OK;
}

//生成一个其值等于串常量 chars 的字符串 T
Status StrAssign(HString &T,char *chars){
	int i=0;
	char *c;
	if (T.ch )					//生成一个其值等于串常量chars 的串T
		free(T.ch );			//释放T原有的空间
	for(c = chars; *c; ++c){    //求chars的长度i
		i++;
	}
	if(!i){
		T.ch = NULL;
		T.length = 0;			//若i=0，则长度等于0
	}else{
		if(!(T.ch = (char *)malloc (i*sizeof (char)))){		//初始化内存空间
			exit(OVERFLOW);
		}
		for(int j=0;j<i;j++){
			T.ch[j]=chars[j];				//将chars赋值给模式串T
		}
		T.length = i;						//i为模式串T的长度
	}
	
	return OK;

}

//返回字符串元素的个数
Status StrLength(HString S){
	//返回S的元素个数，称为串的长度。
	return S.length ;
}

//比较字符串长度
Status StrCompare(HString S,HString T){
	//若S>T，则返回值>0，若S = T,则返回值等于0,若S<T，则返回值小于0
	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串
void ClearString(HString S,HString T){
	
	if(S.ch){
		free(S.ch );
		S.ch = NULL;
	}
	S.length = 0;

}

//输出字符串
Status printStr(HString S){
	for(int i=0;i<=S.length-1;i++){
		printf("%c",S.ch[i]);
	}
	return OK;
}

//连接S1和S2生成的新串S
HString ConcatString(HString &S,HString S1,HString S2){

	if(S.ch){
		free(S.ch);			//释放就空间
	}

	if(!(S.ch = (char *)malloc ((S1.length +S2.length)*sizeof (char)))){
		exit(OVERFLOW );
	}

	for(int i=0; i < S1.length;i++){
		S.ch[i] = S1 .ch[i];
	}
	S.length = S1.length+S2.length ;

	for(int i = S1.length;i < S.length;i++){
		S.ch[i] = S2.ch [i-S1.length];
	}
	
	return S;
}

//用Sub返回串S的第pos 个字符起长度为len的子串
Status SubString(HString Sub,HString S,int pos,int len){
	
	int i,j;
	//其中，1<=pos<=StrLength(T)且0<=len<=Strlength(T)-pos+1
	if(pos<1 || pos > S.length || len <0 || len>S.length-pos+1 ){
		return ERROR ;
	}
	if(Sub.ch){
		free(Sub.ch);
	}
	if(!len){
		Sub.ch = NULL;
		Sub.length = 0;
	}else{
		Sub.ch = (char *)malloc (len * sizeof (char));
		for(i=0,j=pos-1;i<len-1,j<=pos+len-2;i++,j++){
			Sub.ch[i] = S.ch[j];
		}
		Sub.length = len;
	}
	printStr(Sub);

	return OK;
}

//返回主串S中子串T的位置
int Index(HString S,HString T,int pos){
	
	int i=pos-1,j=0;		//从主串的第pos个字符开始和子串的第一个字符比较
	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-j+1;		//返回找到之后的起始位置
	else 
		return 0;

}

//在主串S的第pos位置插入子串T
HString StrInsert(HString S,int pos,HString T){
	
	int i;
	
	if(pos<1||pos>S.length+1){
		exit(OVERFLOW);				//pos 不合法
	}
	if(!(S.ch = (char *)realloc (S.ch,(S.length+T.length)*sizeof(char)))){
		exit(OVERFLOW);
	}

	for(i =StrLength(S);i>=pos-1;i--){		//将pos位之后的向后移
		S.ch[i+T.length] = S.ch[i];			//为插入而腾出位置
	}
	for(i = pos-1; i <= pos+T.length-2; i++){
		S.ch[i] = T.ch[i-pos+1];	//插入
	}

	S.length=S.length+T.length;

	return S;
	
}

// 从串S中删除第pos个字符起长度为len的子串
HString StrDelete(HString S,int pos,int len){

	// 初始条件：串S存在，1<=pos<=StrLength(S)-len+1
	int i;
	if (pos<1 || pos>S.length - len + 1 || len < 0)//pos和len的值超出范围
		exit(OVERFLOW);
	//循环删除子串后的所有字符
	
	for (i = pos + len -1  ; i <= S.length -1 ; i++){
		//向前移动len个位置
		S.ch[i - len] = S.ch[i];
	}
	S.length =S.length-len;//更新串S的长度
	
	return S;
}


//用V替换主串S中出现与Str相等的子串 
Status Replace(HString S,HString T,HString V){
	int pos= 0; //从串S的第一个字符起查找串T
	if(S.length <=0) // S是空串
		return ERROR;
	
	do{
		pos=Index(S,T,pos);				// 返回主串S中第i个字符后存在与T相等的子串
		if(pos){						// 串S中存在串T
			StrDelete(S,pos,StrLength(T));		// 串S中存在串T
			StrInsert(S,pos,V);					// 在原串T的位置插入串V 	
		}//if
	}while(pos);

	return OK;
}

//------------主函数------------
int main(){

	HString Str,S,T,S1,S2,V,Sub;
	//注意必须先初始化，不然没有值输出
	S.ch=NULL;				
	S.length=0;
	S1.ch=NULL;
	S1.length=0;
	S2.ch=NULL;
	S2.length=0;
	T.ch=NULL; 
	T.length=0;
	Str.ch=NULL;
	Str.length=0;
	V.ch=NULL;
	V.length=0;
	Sub.ch=NULL;
	Sub.length=0;
	char s[100],s1[100],s2[100],str[100],v[100];
	int pos=3,len=2;	//给pos和len赋值

	printf("请输入一个字符串S： ");
	gets_s(s);			//接收字符串
	if(StrAssign (T,s))
		printf("字符串的长度为：%d\n",StrLength(T));

	printf("比较串的大小： ");
	printf("%d\n",StrCompare(S,T));
	printf("\n~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
	printf("将S串清空\n");
	ClearString(S,T);
	printf("S串已清空\n");

	printf("\n~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
	printf("用T连接有s1和s2生成的新串：  \n");
	printf("请输入第一个字符串s1：  ");
	gets_s(s1); 
	StrAssign(S1,s1);
	printf("输入字符串S1的长度为：  %d",StrLength(S1));
	printf("\n请输入第个二个字符串s2：  ");
	gets_s(s2);  
	StrAssign(S2,s2);
	printf("输入字符串S2的长度为：  %d",StrLength(S2));
	S = ConcatString(S,S1,S2);
	printf("\n连接生成的新串S是： ");
	printStr(S);

	printf("\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
	printf("\n返回第1个字符之后的子串S2的位置是：   %d ",Index(S,S2,1));
	printf("\n返回插入在主串S的第3个位置插入子串S2:  ");
	S = StrInsert(S,pos,S2);
	printStr(S);

	printf("\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
	printf("返回删除主串S的第3个位置的长度为2的子串： ");
	S = StrDelete(S,pos,len); 
	printStr(S);

	printf("\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
	printf("\n用Sub返回串S的第3个字符起长度为2的子串： ");
	SubString(Sub,S,3,2);

	printf("\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
	printf("串S存在，用V替换S中与Str相等的串\n");
	printf("原来的S串是：  ");
	printStr(S);
	printf("\n请输入S中要替换的串Str：  ");
	gets_s(str); 
	StrAssign(Str,str);
	printf("请输入新串V：  ");
	gets_s(v);
	StrAssign(V,v);
	printf("替换之后的字符串S：  ");
	Replace(S,Str,V);
	printStr(S);
	
	printf("\n\n\n");
	return OK;
}

运行截图：