串的堆分配实现

举报
兔老大 发表于 2021/04/22 01:29:01 2021/04/22
【摘要】 今天,线性结构基本就这样了,以后(至少是最近)就很少写线性基础结构的实现了。 串的类型定义 typedef struct{    char *str;    int length;}HeapString; 初始化串 InitString(HeapString *S){    S->length=0;&...

今天,线性结构基本就这样了,以后(至少是最近)就很少写线性基础结构的实现了。

串的类型定义


  
  1. typedef struct
  2. {
  3.     char *str;
  4.     int length;
  5. }HeapString;


初始化串


  
  1. InitString(HeapString *S)
  2. {
  3.     S->length=0;
  4.     S->str='\0';
  5. }

长度


  
  1. int StrEmpty(HeapString S)
  2. /*判断串是否为空,串为空返回1,否则返回0*/
  3. {
  4.     if(S.length==0)         /*判断串的长度是否等于0*/
  5.         return 1;           /*当串为空时,返回1;否则返回0*/
  6.     else
  7.         return 0;
  8. }
  9. int StrLength(HeapString S)
  10. /*求串的长度操作*/
  11. {
  12.     return S.length;
  13. }


串的赋值


  
  1. void StrAssign(HeapString *S,char cstr[])
  2. /*串的赋值操作*/
  3. {
  4.     int i=0,len;
  5.     if(S->str)
  6.         free(S->str);
  7.     for(i=0;cstr[i]!='\0';i++); /*求cstr字符串的长度*/
  8.         len=i;
  9.     if(!i)
  10.     {
  11.         S->str=NULL;
  12.         S->length=0;
  13.     }
  14.     else
  15.     {
  16.         S->str=(char*)malloc((len+1)*sizeof(char));
  17.         if(!S->str)
  18.             exit(-1);
  19.         for(i=0;i<len;i++)
  20.             S->str[i]=cstr[i];
  21.         S->length=len;
  22.     }
  23. }


串的复制


  
  1. void StrAssign(HeapString *S,char cstr[])
  2. /*串的赋值操作*/
  3. {
  4.     int i=0,len;
  5.     if(S->str)
  6.         free(S->str);
  7.     for(i=0;cstr[i]!='\0';i++); /*求cstr字符串的长度*/
  8.         len=i;
  9.     if(!i)
  10.     {
  11.         S->str=NULL;
  12.         S->length=0;
  13.     }
  14.     else
  15.     {
  16.         S->str=(char*)malloc((len+1)*sizeof(char));
  17.         if(!S->str)
  18.             exit(-1);
  19.         for(i=0;i<len;i++)
  20.             S->str[i]=cstr[i];
  21.         S->length=len;
  22.     }
  23. }


串的插入


  
  1. int StrInsert(HeapString *S,int pos,HeapString T)
  2. /*串的插入操作。在S中第pos个位置插入T分为三种情况*/
  3. {
  4.     int i;
  5.     if(pos<0||pos-1>S->length)      /*插入位置不正确,返回0*/
  6.     {
  7.         printf("插入位置不正确");
  8.         return 0;
  9.     }
  10.     S->str=(char*)realloc(S->str,(S->length+T.length)*sizeof(char));
  11.     if(!S->str)
  12.     {
  13.         printf("内存分配失败");
  14.         exit(-1);
  15.     }
  16.     for(i=S->length-1;i>=pos-1;i--)
  17.         S->str[i+T.length]=S->str[i];
  18.     for(i=0;i<T.length;i++)
  19.         S->str[pos+i-1]=T.str[i];
  20.     S->length=S->length+T.length;
  21.     return 1;
  22. }


串的删除


  
  1. int StrDelete(HeapString *S,int pos,int len)
  2. /*在串S中删除pos开始的len个字符*/
  3. {
  4.     int i;
  5.     char *p;
  6.     if(pos<0||len<0||pos+len-1>S->length)
  7.     {
  8.         printf("删除位置不正确,参数len不合法");
  9.         return 0;
  10.     }
  11.     p=(char*)malloc(S->length-len);             /*p指向动态分配的内存单元*/
  12.     if(!p)
  13.         exit(-1);
  14.     for(i=0;i<pos-1;i++)                        /*将串第pos位置之前的字符复制到p中*/
  15.         p[i]=S->str[i];
  16.     for(i=pos-1;i<S->length-len;i++)                /*将串第pos+len位置以后的字符复制到p中*/
  17.         p[i]=S->str[i+len];
  18.     S->length=S->length-len;                    /*修改串的长度*/
  19.     free(S->str);                           /*释放原来的串S的内存空间*/
  20.     S->str=p;                               /*将串的str指向p字符串*/
  21.     return 1;
  22. }



串的比较


  
  1. int StrCompare(HeapString S,HeapString T)
  2. /*串的比较操作*/
  3. {
  4. int i;
  5. for(i=0;i<S.length&&i<T.length;i++) /*比较两个串中的字符*/
  6.     if(S.str[i]!=T.str[i])          /*如果出现字符不同,则返回两个字符的差值*/
  7.         return (S.str[i]-T.str[i]);
  8. return (S.length-T.length);             /*如果比较完毕,返回两个串的长度的差值*/
  9. }


串的连接


  
  1. int StrCat(HeapString *T,HeapString S)
  2. /*将串S连接在串T的后面*/
  3. {
  4.     int i;
  5.     T->str=(char*)realloc(T->str,(T->length+S.length)*sizeof(char));
  6.     if(!T->str)
  7.     {
  8.         printf("分配空间失败");
  9.         exit(-1);
  10.     }
  11.     else
  12.     {
  13.         for(i=T->length;i<T->length+S.length;i++)   /*串S直接连接在T的末尾*/
  14.             T->str[i]=S.str[i-T->length];
  15.         T->length=T->length+S.length;           /*修改串T的长度*/
  16.     }
  17.     return 1;
  18. }


清空串


  
  1. void StrClear(HeapString *S)
  2. /*清空串,只需要将串的长度置为0即可*/
  3. {
  4.     S->str='\0';
  5.     S->length=0;
  6. }


销毁串


  
  1. void StrDestroy(HeapString *S)
  2. {
  3.     if(S->str)
  4.         free(S->str);
  5. }

打印


  
  1. void StrPrint(HeapString S)
  2. {
  3. int i;
  4. for(i=0;i<S.length;i++)
  5. {
  6. printf("%c",S.str[i]);
  7. }
  8. printf("\n");
  9. }


 

文章来源: fantianzuo.blog.csdn.net,作者:兔老大RabbitMQ,版权归原作者所有,如需转载,请联系作者。

原文链接:fantianzuo.blog.csdn.net/article/details/83862545

【版权声明】本文为华为云社区用户转载文章,如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。