【练习】块链串的实现

  为了方便串的操作，当以链表存储串值时，除表头指针外，还可附设一个尾指针来指示链表中的最后一个结点，并给出当前串的长度。这样的串存储结构称为块链结构。

• 串的存储结构类型

#define ChunkSize 4
#define stuff '#'
/*串的结点类型定义*/
typedef struct Chunk
{
    char ch[ChunkSize];
    struct Chunk *next;
}Chunk;
/*链串的类型定义*/
typedef struct
{
    Chunk *head;
    Chunk *tail;
    int length;
}LinkString;

• 初始化串

void InitString(LinkString *S)
/*初始化字符串S*/
{
    S->length=0;            /*将串的长度置为0*/
    S->head=S->tail=NULL;   /*将串的头指针和尾指针置为空*/
}

• 串的赋值

int StrAssign(LinkString *S,char *cstr)
/*生成一个其值等于cstr的串S。成功返回1，否则返回0*/
{
    int i,j,k,len;
    Chunk *p,*q;
    len=strlen(cstr);                   /*len为链串的长度 */
    if(!len)
        return 0;
    S->length=len;
        j=len/ChunkSize;                /*j为链串的结点数 */
    if(len%ChunkSize)
        j++;
    for(i=0;i<j;i++)
    {
        p=(Chunk*)malloc(sizeof(Chunk));    /*动态生成一个结点*/
        if(!p)
            return 0;
        for(k=0;k<ChunkSize&&*cstr;k++) /*将字符串ctrs中的字符赋值给链串的数据域*/
            *(p->ch+k)=*cstr++;
        if(i==0)                        /*如果是第一个结点*/
            S->head=q=p;                /*头指针指向第一个结点*/
        else
        {
            q->next=p;
            q=p;
        }
        if(!*cstr)                      /*如果是最后一个链结点*/
        {
            S->tail=q;                  /*将尾指针指向最后一个结点*/
            q->next=NULL;               /*将尾指针的指针域置为空*/
            for(;k<ChunkSize;k++)       /*将最后一个结点用'#'填充*/
            *(q->ch+k)=stuff;
        }
    }
    return 1;
}

• 串的状态

int StrEmpty(LinkString S)
/*判断串是否为空。如果S为空串，则返回1，否则返回0*/
{
   if(S.length==0)                      /*如果串为空，返回1 */
     return 1;
   else                             /*如果串非空，返回0 */
     return 0;
 }
int StrLength(LinkString S)
/*求串的长度 */
{
    return S.length;
}

• 串的复制

int StrCopy(LinkString *T,LinkString S)
/*串的复制操作*/
{
    char *str;
    int flag;
    if(!ToChars(S,&str))        /*将串S中的字符拷贝到字符串str中*/
        return 0;
    flag=StrAssign(T,str);      /*将字符串str的字符赋值到串T中*/
    free(str);              /*释放str的空间 */
    return flag;
 }

• 串的转换

int ToChars(LinkString S,char **cstr)
/*串的转换操作。将串S的内容转换为字符串，将串S中的字符拷贝到cstr。成功返回1，否则返回0*/
{
    Chunk *p=S.head;            /*将p指向串S中的第1个结点*/
    int i;
    char *q;
    *cstr=(char*)malloc((S.length+1)*sizeof(char));
    if(!cstr||!S.length)
        return 0;
        q=*cstr;                    /*将q指向cstr */
    while(p) /*块链没结束 */
    {
        for(i=0;i<ChunkSize;i++)
        if(p->ch[i]!=stuff)     /*如果当前字符不是填充的特殊字符'#'，则将S中字符赋值给q*/
        *q++=(p->ch[i]);
        p=p->next;
    }
    (*cstr)[S.length]=0;             /*在字符串的末尾添加结束标志*/
    return 1;
}

• 串的比较

int StrCompare(LinkString S,LinkString T)
/*串的比较操作。若S的值大于T，则返回正值；若S的值等于T，则返回0；若S的值小于T，则返回负值*/
{
    char *p,*q;
    int flag;
    if(!ToChars(S,&p))          /*将串S转换为字符串p*/
        return 0;
    if(!ToChars(T,&q))          /*将串T转换为字符串q*/
        return 0;
    for(;*p!='\0'&&*q!='\0';)
        if(*p==*q)
        {
            p++;
            q++;
        }
        else
            flag=*p-*q;
    free(p);                    /*释放p的空间 */
    free(q);                    /*释放q的空间*/
    if(*p=='\0'||*q=='\0')
        return S.length-T.length;
    else
        return flag;
}

• 串的连接

int StrConcat(LinkString *T,LinkString S)
/*串的链接操作。将串S连接在串T的尾部*/
{
    int flag1,flag2;
    LinkString S1,S2;
    InitString(&S1);
    InitString(&S2);
    flag1=StrCopy(&S1,*T);          /*将串T的内容拷贝到S1中*/
    flag2=StrCopy(&S2,S);               /*将串S的内容拷贝到S2中*/
    if(flag1==0||flag2==0)          /*如果有一个串拷贝不成功，则返回0*/
        return 0;
    T->head=S1.head;                /*修改串T的头指针*/
    S1.tail->next=S2.head;          /*将串S1和S2首尾相连*/
    T->tail=S2.tail;                    /*修改串T的尾指针*/
    T->length=S.length+T->length;       /*修改串T的长度*/
    return 1;
}

• 串的插入

int StrInsert(LinkString *S, int pos,LinkString T)
/*串的插入操作。在串S的第pos个位置插入串T*/
{
    char *t1,*s1;
    int i,j;
    int flag;
    if(pos<1||pos>S->length+1)      /*如果插入位置不合法*/
        return 0;
    if(!ToChars(*S,&s1))                /*将串S转换为字符串s1*/
        return 0;
    if(!ToChars(T,&t1))             /*将串T转换为字符串t1*/
        return 0;
    j=strlen(s1);                   /*j为字符串s1的长度*/
    s1=(char*)realloc(s1,(j+strlen(t1)+1)*sizeof(char));     /*为s1重新分配空间*/
    for(i=j;i>=pos-1;i--)
        s1[i+strlen(t1)]=s1[i];             /*将字符串s1中的第pos以后的字符向后移动strlen(t1)个位置*/
    for(i=0;i<(int)strlen(t1);i++)      /*在字符串s1中插入t1*/
        s1[pos+i-1]=t1[i];
    InitString(S);                  /*释放S的原有存储空间*/
    flag=StrAssign(S,s1);           /*由s1生成串S*/
    free(t1);
    free(s1);
    return flag;
}

• 串的删除

int StrDelete(LinkString *S,int pos,int len)
/*串的删除操作。将串S中的第pos个字符起长度为len的子串删除*/
{
    char *str;
    int i;
    int flag;
    if(pos<1||pos>S->length-len+1||len<0)   /*参数不合法*/
        return 0;
    if(!ToChars(*S,&str))                   /*将串S转换为字符串str*/
        return 0;
    for(i=pos+len-1;i<=(int)strlen(str);i++)        /*将字符串中第pos个字符起的长度为len的子串删除*/
        str[i-len]=str[i];
    InitString(S);                      /*释放S的原有存储空间*/
    flag=StrAssign(S,str);                   /*将字符串str转换为串S*/
    free(str);
    return flag;
}

• 取子串操作

int SubString(LinkString *Sub, LinkString S,int pos,int len)
/*取子串操作。用Sub返回串S的第pos个字符起长度为len的子串。*/
{
    char *t,*str;
    int flag;
    if(pos<1||pos>S.length||len<0||len>S.length-pos+1)  /*参数不合法*/
        return 0;
    if(!ToChars(S,&str))            /*将串S转换为字符串str*/
        return 0;
    t=str+pos-1;                /*t指向字符串str中的pos个字符*/
    t[len]='\0';                    /* 将Sub结束处置为'\0'*/
    flag=StrAssign(Sub,t);      /*将字符串t转换为Sub */
    free(str);
    return flag;
}

• 清空串

void ClearString(LinkString *S)
/*清空串操作。将串的空间释放*/
{
    Chunk *p,*q;
    p=S->head;
    while(p)
    {
        q=p->next;
        free(p);
        p=q;
    }
    S->head=S->tail=NULL;
    S->length=0;
}

• 测试示例

/*包含头文件及链串的基本操作实现文件*/
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include"LinkString.h"
void StrPrint(LinkString S);
void main()
{
    int i,j;
    int flag;
    LinkString S1,S2,S3,Sub;
    char *str1="Welcome to";
    char *str2=" Data Structure";
    char *str3="Computer Architecture";
    printf("串的初始化和赋值操作:\n");
    InitString(&S1);                    /*串S1，S2，S3的初始化*/
    InitString(&S2);
    InitString(&S3);
    InitString(&Sub);
    StrAssign(&S1,str1);                /*串S1，S2，S3的赋值操作*/
    StrAssign(&S2,str2);
    StrAssign(&S3,str3);
    printf("串S1的值是:");
    StrPrint(S1);
    printf("串S2的值是:");
    StrPrint(S2);
    printf("串S3的值是:");
    StrPrint(S3);
    printf("将串S2连接在串S1的末尾:\n");
    StrConcat(&S1,S2);                  /*将串S2连接在串S1的末尾*/
    printf("S1是:");
    StrPrint(S1);
    printf("将串S1的第12个位置后的14个字符删除:\n");
    StrDelete(&S1,12,14);               /*将串S1中的第12个位置后的14个字符删除*/
    printf("S1是:");
    StrPrint(S1);
    printf("将串S2插入到串S1中的第12个字符后:\n");
    StrInsert(&S1,12,S3);               /*将串S3插入到串S1的第12个字符后*/
    printf("S1是:");
    StrPrint(S1);
    printf("将串S1中的第12个字符后的8个字符取出并赋值给串Sub:\n");
    SubString(&Sub,S1,12,8);            /*将串S1中的第12个位置后的8个字符取出赋值给Sub*/
    printf("Sub是:");
    StrPrint(Sub);
}

void StrPrint(LinkString S)
/*链串的输出*/
{
    int i=0,j;
    Chunk *h;
    h=S.head;                       /*h指向第一个结点*/
    while(i<S.length)
    {
        for(j=0;j<ChunkSize;j++)    /*输出块中的每一个字符*/
            if(*(h->ch+j)!=stuff)   
            {
                printf("%c",*(h->ch+j));
                i++;
            }
            h=h->next;              /*h指向下一个结点*/
    }
    printf("\n");
}

• 测试结果