BDS之串

串是由零个或多个字符组成的有限序列，一般记为 S=a1‘a2'a3'....an' （n>=0）。一般我们讨论串的模型可以分为三种类型，分别是定长顺序存储模型，堆分配存储模型，块链存储模型，其中定长顺序存储模型最简单，它基于静态数组就可以实现。

//串的定长顺序存储表示
#define MAX_STR_LEN 30
typedef int Status;
typedef unsigned char SString[MAX_STR_LEN+1];//0号单元存放串的长度
typedef unsigned int size_t;

Status str_assign(SString T,char* src)
{
	int i ;
	int src_len = strlen(src);
	if(src_len>MAX_STR_LEN)
		return ERROR;
	else{
		T[0]=src_len;
		for(i=1;i<=T[0];i++)
			T[i]=*(src+i-1);		
		return OK;
	}
}
void str_copy(SString T,SString S)
{
	int i;
	for(i=0;i<=S[0];i++)
		T[i]=S[i];
}

bool str_empty(SString S)
{
	if(S[0]==0)
		return true;
	else
		return false;
}
int str_cmp(SString S,SString T)
{
	int i;
	for(i=1;i<=S[0]&&iS[0] || len<0 || len>S[0])
		return ERROR;
	for(i=1;i<=len;i++)
		sub[i]=S[pos+i-1];
	sub[0]=len;
	return OK;
}

int index(SString S,SString T,int pos)
{
	int i,j;
	if(1<=pos&&pos<=S[0]){
		i=pos;
		j=1;
		while(i<=S[0]&&j<=T[0]){
			if(S[i]==T[j]){
				++i;
				++j;
			}else{
				i=i-j+2;
				j=1;
			}
		}
		if(j>T[0])
			return i-T[0];
		else
			return 0;
	}
	return 0;
}

Status str_insert(SString S,int pos,SString T)
{
	int i,n;
	if(pos<1||pos>S[0]+1)
		return ERROR;
	if(S[0]+T[0]<=MAX_STR_LEN){
		for(i=S[0];i>=pos;i--){
			S[i+T[0]] = S[i];
		}
		for(i=1;i<=T[0];i++){
			S[pos+i-1]=T[i];
		}
		S[0]+=T[0];
		return TRUE;
	}else{
		n = (MAX_STR_LEN-S[0]); //需要插入的元素数目 
		for(i=S[0];i>=pos;i--){
			S[i+n]=S[i];
		}
		for(i=1;i<=n;i++){
			S[pos+i-1]=T[i];
		}
		S[0]=MAX_STR_LEN;
		return FALSE;
	}
}

size_t str_len(SString S)
{
	return S[0];
}

Status str_delete(SString S,int pos,int len)
{
	int i;
	if(pos<1||pos>S[0]-len+1||len<0)
		return ERROR;
	for(i=pos+len;i<=S[0];i++){
		S[i-len]=S[i];
	}
	S[0]-=len;
	return OK;
}

Status replace(SString S,SString T,SString V)
{
	int i=1;
	Status s;
	if(str_empty(T))
		return ERROR;
	do{
		i = index(S,T,i);
		if(i){
			str_delete(S,i,str_len(T));
			s=str_insert(S,i,V);
			if(!s)
				return ERROR;
			i+=str_len(V);
		}
	}while(i);
	return OK;
}

最常见的是基于堆分配存储的表示方式，这种存储表示的特点是，它们的存储空间是在程序执行过程中动态分配而得到的。

#define ERROR -1
#define OK   0
typedef int Status ;
typedef unsigned int size_t;

#define STR_ININ_SIZE	16

//基于堆存储的串表示
struct HString 
{
	char* ch;
	int length;
};

void str_init(HString &T)
{
	T.ch = NULL;
	T.length = 0;
}

Status str_assign(HString &T,char* str)
{
	int i,j;
	if(T.ch)
		free(T.ch);
	size_t len = strlen(str);
	if(!len){
		T.ch = NULL;
		T.length = 0;
	}else{
		T.ch = (char*)malloc(len*sizeof(char));
		if(!T.ch){		
			return ERROR;
		}		
		for(i=0;iS.length || len<0 || len>S.length-pos)
		return ERROR;
	if(sub.ch)
		free(sub.ch);
	if(!len){
		sub.ch = NULL;
	}else{		
		sub.ch = (char*)malloc(sizeof(char));
		if(!sub.ch)
			return ERROR;
		for(i = 0;iS.length)
		return ERROR;
	if(T.length){
		S.ch = (char*)realloc(S.ch,(S.length+T.length)*sizeof(char));
		if(!S.ch)
			return ERROR;
		for(i=S.length-1;i>=pos;i--)
			S.ch[i+T.length] = S.ch[i];
		for(i=0;iS.length || S.length-pos =0){
		n = str_len(S);
		m = str_len(T);
		i = pos;
		while(i<=n-m){
			str_sub(sub,S,i,m);
			if(str_cmp(sub,T)!=0)
				++i;
			else
				return i;
		}
	}
	return 0;
}


Status replace(HString &S,HString T,HString V)
{
	int i =1;
	if(str_empty(T))
		return ERROR;
	do{
		i = index(S,T,i);
		if(i){
			str_delete(S,i,str_len(T));
			str_insert(S,i,V);
			i+=str_len(V);
		}
	}while(i);
	return OK;
}

可以看到，关于串的结构类似于线性表，实现起来非常简单，也很容易理解。