数据结构-串

计算机上的非数值处理的对象基本上是字符串数据。串是由零个或多个字符组成的有限序列，一般记为

s='a1a2..an'

其中s是串的名，用单引号括起来的字符系序列是串的值；ai可以是字母、数字或其他字符，串中字符的数目n称为串的长度。零个字符的串称为空串。它的长度为零。

存储的时候，我们用堆存储。存储空间是在程序执行过程中动态分配而得。

首先是辅助宏的定义：

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OVERFLOW -1
typedef int Status;

串的存储结构定义：

//串的堆存储结构定义
typedef struct{
    char *ch; 
    int length;//串长度
}HString;

初始化一个空串.

Status InitString(HString &T){
    //初始化一个空串
    T.ch=NULL;
    T.length=0;
    return OK;
}

生成一个其值等于串常量chars 的串T.

Status StrAssign(HString &T,char *chars){
    //生成一个其值等于串常量chars 的串T
    if(T.ch) //如果T串不空 释放原有空间
        free(T.ch);
    int n=0,i=0;
    while(chars[n]!='\0')
         n++; //求chars的串长 n
    if(!n) //如果串长为0  T串赋空
         T.ch=NULL;
    else{
         T.ch=(char *)malloc(n*sizeof(char));
         if(!T.ch) //存储分配失败
             exit(OVERFLOW);
         while(chars[i]!='\0')
             T.ch[i]=chars[i++];
    }
    T.length=n;
    return OK;
}

若S>T 则返回值>0，若S==T 则返回值==0 若S<T 则返回值<0.

int 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为空串 返回TRUE 否则返回FALSE.

Status StrEmpty(HString S){
    //若串S为空串 返回TRUE 否则返回FALSE
    if(!S.length)
        return TRUE;
    return FALSE;
}

返回串的长度.

int  StrLength(HString &S){
    //返回串的长度
    return S.length;
}

如果S串存在 就销毁S串.

Status DestroyString(HString &S){
    //如果S串存在 就销毁S串
    if(S.ch)
        free(S.ch);
    S.ch=NULL; //赋空S串
    S.length=0;
    return OK;
}

清空串S.

Status ClearString(HString &S){
   //清空串S
    S.length=0;
    return OK;
}

输出串S.

Status PrintString(HString &S){
    //输出串S
    if(!S.length) //空串
        printf("空串");
    else{
       int i;
       for(i=0;i<S.length;i++)
           printf("%c",S.ch[i]);
    }
    printf("\n");
    return OK;
}

由串S复制的串T.

Status StrCopy(HString &T,HString S){
     //由串S复制的串T
     if(T.ch) //如果串T不空 释放原有空间
        free(T.ch);
     T.length=S.length;
     if(S.length){ //如果S不为空串
         int i=0;
         T.ch=(char *)malloc(T.length*sizeof(char));
         if(!T.ch) //存储分配失败
             exit(OVERFLOW);
         for(i=0;i<T.length;i++)
             T.ch[i]=S.ch[i];
     }
     else //否则T串赋空
         T.ch=NULL;
     return OK;
}

用Sub返回串S中的第pos个字符起长度为len的字串,pos>=1&&pos<=S.length  len>=0&&len<=S.length-pos+1.

Status SubString(HString &Sub,HString S,int pos,int len)
{
     //用Sub返回串S中的第pos个字符起长度为len的字串
     //pos>=1&&pos<=S.length len>=0&&len<=S.length-pos+1
    if(pos<1||pos>S.length||len<0||len>S.length-pos+1)
        return ERROR;//pos不合法或者len不合法
    if(Sub.ch)//如果字串不空 释放原有空间
        free(Sub.ch);
    if(len) {//如果len不为0
        int j=0,i;
        Sub.ch=(char *)malloc(len*sizeof(char));
        if(!Sub.ch)//存储分配失败
            exit(OVERFLOW);
        for(i=pos-1;i<pos+len-1;i++)
            Sub.ch[j++]=S.ch[i];
    }
    else//否则字串赋空
         Sub.ch=NULL;
    Sub.length=len;
    return OK;
}

用T返回S1与S2拼接成的串.

Status Concat(HString &T,HString S1,HString S2){
    //用T返回S1与S2拼接成的串
    if(T.ch) //原来T串不空 释放T原来的空间
        free(T.ch);
    T.length=S1.length+S2.length;
    if(T.length){ //如果S1与S2不同时为空
        int i,j;
         T.ch=(char *)malloc(T.length*sizeof(char));
        if(!T.ch)//存储分配失败
             exit(OVERFLOW);
        for(i=0;i<S1.length;i++)
             T.ch[i]=S1.ch[i];
        for(j=0;j<S2.length;j++)
             T.ch[i+j]=S2.ch[j];	 
    }
    else //否则T串赋空
        T.ch=NULL;
    return OK;
}

在串S的第pos个字符前插入串T pos>=1&&pos<=S.length+1.

Status StrInsert(HString &S,int pos,HString T){
    //在串S的第pos个字符前插入串T pos>=1&&pos<=S.length+1
    if(pos<1||pos>S.length+1) //pos值非法
        return ERROR;
    int i,j=0;
    if(T.length) {   //如果T串不为空 重新分配存储空间
          S.ch=(char *)realloc(S.ch,(S.length+T.length)*sizeof(char));
    if(!S.ch) //存储分配失败
          exit(OVERFLOW);
    for(i =S.length-1;i>=pos-1;i--) //为插入T而腾出位置
          S.ch[i+T.length]=S.ch[i];
    for(i=pos-1;i<pos-1+T.length;i++)//插入T
          S.ch[i]=T.ch[j++];
    S.length+=T.length;
    }
    return OK;
}

从串S中删除第pos个字符开始，长度为len的字串. pos>=1&&pos<=S.length+1 len>=0&&len<=S.length-pos+1

Status StrDelete(HString &S,int pos,int len){
    //从串S中删除第pos个字符开始，长度为len的字串
    //pos>=1&&pos<=S.length+1 len>=0&&len<=S.length-pos+1
    if(pos<1||pos>S.length+1||len<0||len>S.length-pos+1)
        return ERROR;
    int i;
    for(i=pos-1;i<S.length-len;i++) //元素前移
         S.ch[i]=S.ch[i+len];
    S.length-=len;//长度减少
    return OK;
}