串的堆分配实现

客官°小女子只卖身不卖艺 2022-04-18 04:40 133阅读 0赞

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

串的类型定义

typedef struct
    {
        char *str;
        int length;
    }HeapString;

初始化串

InitString(HeapString *S)
    {
        S->length=0;
        S->str='\0';
    }

长度

int StrEmpty(HeapString S)
    /*判断串是否为空，串为空返回1，否则返回0*/
    {
        if(S.length==0)         /*判断串的长度是否等于0*/
            return 1;           /*当串为空时，返回1；否则返回0*/
        else
            return 0;
    }
    int StrLength(HeapString S)
    /*求串的长度操作*/
    {
        return S.length;
    }

串的赋值

void StrAssign(HeapString *S,char cstr[])
    /*串的赋值操作*/
    {
        int i=0,len;
        if(S->str)
            free(S->str);
        for(i=0;cstr[i]!='\0';i++); /*求cstr字符串的长度*/
            len=i;
        if(!i)
        {
            S->str=NULL;
            S->length=0;
        }
        else
        {
            S->str=(char*)malloc((len+1)*sizeof(char));
            if(!S->str)
                exit(-1);
            for(i=0;i<len;i++)
                S->str[i]=cstr[i];
    
            S->length=len;
        }
    }

串的复制

串的插入

int StrInsert(HeapString *S,int pos,HeapString T)
    /*串的插入操作。在S中第pos个位置插入T分为三种情况*/
    {
        int i;
        if(pos<0||pos-1>S->length)      /*插入位置不正确，返回0*/
        {
            printf("插入位置不正确");
            return 0;
        }
        S->str=(char*)realloc(S->str,(S->length+T.length)*sizeof(char));
        if(!S->str)
        {
            printf("内存分配失败");
            exit(-1);
        }
    
        for(i=S->length-1;i>=pos-1;i--)
            S->str[i+T.length]=S->str[i];
        for(i=0;i<T.length;i++)
            S->str[pos+i-1]=T.str[i];
    
        S->length=S->length+T.length;
        return 1;
    }

串的删除

int StrDelete(HeapString *S,int pos,int len)
    /*在串S中删除pos开始的len个字符*/
    {
        int i;
        char *p;
        if(pos<0||len<0||pos+len-1>S->length)
        {
            printf("删除位置不正确，参数len不合法");
            return 0;
        }
        p=(char*)malloc(S->length-len);             /*p指向动态分配的内存单元*/
        if(!p)
            exit(-1);
        for(i=0;i<pos-1;i++)                        /*将串第pos位置之前的字符复制到p中*/
            p[i]=S->str[i];
        for(i=pos-1;i<S->length-len;i++)                /*将串第pos+len位置以后的字符复制到p中*/
            p[i]=S->str[i+len];
        S->length=S->length-len;                    /*修改串的长度*/
        free(S->str);                           /*释放原来的串S的内存空间*/
        S->str=p;                               /*将串的str指向p字符串*/
        return 1;
    }

串的比较

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

串的连接

int StrCat(HeapString *T,HeapString S)
    /*将串S连接在串T的后面*/
    {
        int i;
        T->str=(char*)realloc(T->str,(T->length+S.length)*sizeof(char));
        if(!T->str)
        {
            printf("分配空间失败");
            exit(-1);
        }
        else
        {
            for(i=T->length;i<T->length+S.length;i++)   /*串S直接连接在T的末尾*/
                T->str[i]=S.str[i-T->length];
            T->length=T->length+S.length;           /*修改串T的长度*/
        }
        return 1;
    }

清空串

void StrClear(HeapString *S)
    /*清空串，只需要将串的长度置为0即可*/
    {
    
        S->str='\0';
        S->length=0;
    }

销毁串

void StrDestroy(HeapString *S)
    {
        if(S->str)
            free(S->str);
    }

打印

void StrPrint(HeapString S)
    {
        int i;
        for(i=0;i<S.length;i++)
        {
            printf("%c",S.str[i]);
        }
        printf("\n");
    }