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]&&i<T[0];i++){
		if(S[i]==T[i])
			continue;
		return S[i]-T[i];
	}
	return S[0]-T[0];
}
void clear_str(SString S)
{
	S[0]=0;
}

Status contact(SString T,SString S1,SString S2)
{
	int i;
	if(S1[0]+S2[0]<=MAX_STR_LEN){
		for(i=1;i<=S1[0];i++)
			T[i]=S1[i];
		for(i=1;i<=S2[0];i++)
			T[S1[0]+i]=S2[i];
		T[0]=S1[0]+S2[0];
		return true;
	}else{
		for(i=1;i<=S1[0];i++)
			T[i]=S1[i];
		for(i=1;i<=MAX_STR_LEN-S1[0];i++)
			T[S1[0]+i]=S2[i];
		T[0]=MAX_STR_LEN;
		return false;
	}
}
Status sub_string(SString sub,SString S,int pos,int len)
{
	int i;
	if(pos<1 || pos>S[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;i<len;i++)
			T.ch[i]=*(str+i);
		T.length = len;
	}
	return OK;
}

void str_clear(HString &S)
{
	if(S.ch)
		free(S.ch);
	S.ch=NULL;
	S.length = 0;
}

int str_len(HString S)
{
		return S.length;
}

Status str_concat(HString &T,HString S1,HString S2)
{
	int i;
	if(T.ch)
		free(T.ch);
	T.length = S1.length+S1.length;
	T.ch = (char*)malloc(T.length*sizeof(char));
	if(!T.ch)
		return ERROR;
	for(i=0;i<S1.length;i++)
		T.ch[i]=S1.ch[i];
	for(i=0;i<S2.length;i++)
		T.ch[i+S1.length]=S2.ch[i];	
	return OK;
}

Status str_copy(HString &T,HString S)
{
	int i;
	if(T.ch)
		free(T.ch);	
	T.ch = (char*)malloc(S.length*sizeof(char));
	if(!T.ch)
		return ERROR;
	for(i=0;i<S.length;i++)
		T.ch[i]=S.ch[i];
	T.length = S.length;
	return OK;
}

bool str_empty(HString S)
{
	return  (!S.ch && S.length==0)? true:false;
}

int str_cmp(HString S,HString T)
{
	int i=0;
	for(;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;
}

Status str_sub(HString &sub,HString S,int pos,int len)
{
	int i;
	if(pos<0 || pos>S.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;i<len;i++)
			sub.ch[i] = S.ch[pos+i];  
	}
	sub.length = len;
	return OK;
}
//pos:base 0
Status str_insert(HString &S,int pos,HString T)
{
	int i;
	if(pos<0 || pos>S.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;i<T.length;i++)
			S.ch[i+pos]=T.ch[i];
		S.length += T.length;
	}
	return OK;
}

Status str_delete(HString &S,int pos,int len)
{
	int i;
	if(pos<0 || pos>S.length || S.length-pos <len)
		return ERROR;
	for(i=pos;i<S.length;i++)
		S.ch[i]=S.ch[i+len];
	S.length -=len;
	if(S.length!=len){
		S.ch = (char*)realloc(S.ch,(S.length)*sizeof(char));
		if(!S.ch)
			return ERROR;
	}	
	return OK;
}

int index(HString S,HString T,int pos)
{
	int n, m,i;
	HString sub;
	str_init(sub);

	if(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;
}

可以看到，關於串的結構類似於線性表，實現起來非常簡單，也很容易理解。