【練習】串的堆分配實現

  在C語言中，函式malloc和free管理堆的儲存空間，。利用函式malloc為串動態分配一塊儲存空間， 若分配成功，返回儲存空間起始地址的指標作為串的基地址（起始地址）。如果記憶體單元使用完，呼叫函式free釋放記憶體空間。

• 串的型別定義

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

• 初始化串

InitString(HeapString *S)
{
    S->length=0;/*將串的長度置為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;
    }
}

• 串的複製

void StrCopy(HeapString *T,HeapString S)
/*串的複製操作.*/
{
    int i;
    T->str=(char*)malloc(S.length*sizeof(char));
    if(!T->str)
        exit(-1);
    for(i=0;i<S.length;i++)     /*將串S的字元賦值給串T*/
        T->str[i]=S.str[i];

    T->length=S.length;         /*將串S的長度賦值給串T*/
}

• 串的插入

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)       /*如果引數不合法，則返回0*/
    {
        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;
}

• 取子串

int SubString(HeapString *Sub,HeapString S,int pos,int len)
/*將從串S中的第pos個位置擷取長度為len的子串賦值給Sub*/
{
    int i;
    if(Sub->str)
        free(Sub->str);
    if(pos<0||len<0||pos+len-1>S.length)            /*如果引數不合法，則返回0*/
    {
        printf("引數pos和len不合法");
        return 0;
    }
    else
    {
        Sub->str=(char*)malloc(len*sizeof(char));
        if(!Sub->str)
        {
            printf("儲存分配失敗");
            exit(-1);
        }
        for(i=0;i<len;i++)                      /*將串S的第pos個位置長度為len的字元賦值給Sub*/
            Sub->str[i]=S.str[i+pos-1];

        Sub->length=len;                    /*修改Sub的長度*/
        return 1;
    }
}

• 串的替換

int StrReplace(HeapString *S,HeapString T,HeapString V)
/*將串S中的所有子串T用V替換*/
{
    int i=0;
    int flag;
    if(StrEmpty(T))                     /*如果T是空串，返回0*/
        return 0;
    do
    {
        i=StrIndex(*S,i,T);             /*利用串的定位函式在串S中查詢T的位置*/
        if(i)
        {
            StrDelete(S,i,StrLength(T));    /*如果找到子串T，則將S中的串T刪除*/
            flag=StrInsert(S,i,V);      /*將子串V插入到原來刪除T的位置*/
            if(!flag)                   /*如果沒有插入成功，則返回0*/
                return 0;
            i+=StrLength(V);            /*在串S中，跳過子串V長度個字元，繼續查詢T*/
        }
    }while(i);
    return 1;
}

• 查詢子串

int StrIndex(HeapString S,int pos,HeapString T)
/*在主串S中的第pos個位置開始查詢子串T，如果找到返回子串在主串的位置；否則，返回0*/
{
    int i,j;
    if(StrEmpty(T))                 /*如果串T為空，則返回0*/
        return 0;
    i=pos;
    j=0;
    while(i<S.length&&j<T.length)
    {
        if(S.str[i]==T.str[j])      /*如果串S和串T中對應位置字元相等，則繼續比較下一個字元*/
        {
            i++;
            j++;
        }
        else                    /*如果當前對應位置的字元不相等，則從串S的下一個字元開始，T的第0個字元開始比較*/
        {
            i=i-j+1;
            j=0;
        }
    }
    if(j>=T.length)                 /*如果在S中找到串T，則返回子串T在主串S的位置*/
        return i-j+1;
    else
        return 0;
}

• 清空串

void StrClear(HeapString *S)
/*清空串，只需要將串的長度置為0即可*/
{

    S->str='\0';
    S->length=0;
}

• 銷燬串

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

• 測試示例

/*包含標頭檔案和串的實現檔案*/
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include"HeapString.h"
void StrPrint(HeapString S);    /*串的輸出函式宣告*/
void main()
{
    HeapString S1,S2,Sub;
    char *p;
    char ch[50];
    /*初始化串S1，S2和Sub*/   
    InitString(&S1);
    InitString(&S2);
    InitString(&Sub);
    printf("請輸入第一個字串：");
    gets(ch);
    StrAssign(&S1,ch);              /*通過輸入將串S1賦值*/
    printf("經過賦值操作後的串S1：\n");
    StrPrint(S1);
    printf("請輸入第二個字串：");
    gets(ch);
    StrAssign(&S2,ch);              /*通過輸入將串S2賦值*/
    printf("經過賦值操作後的串S2：\n");
    StrPrint(S2);
    printf("把串S2連線在串S1的末尾，S1串為：\n");
    StrCat(&S1,S2);                 /*將串S2連線在串S1的末尾*/
    StrPrint(S1);
    printf("經過賦值操作後的串Sub：\n");
    StrAssign(&Sub,"Everyone");     /*將串Sub賦值*/
    StrPrint(Sub);
    printf("將串S2插入到串S1的第一位置：\n");
    StrInsert(&S1,1,Sub);           /*將串Sub插入到串S1的第一位置*/
    StrPrint(S1);
    printf("把串S1的第1個位置之後的8個字元刪除：\n");
    StrDelete(&S1,1,8);             /*將串S1的第一位置後的8個字元刪除*/
    StrPrint(S1);
    printf("將串S1中的S2置換為Sub：\n");
    StrAssign(&Sub,"Xi'an");        /*將串Sub重新賦值*/
    StrReplace(&S1,S2,Sub);         /*用串Sub取代串S1中的S2*/
    StrPrint(S1);
    /*將串S1，S2和Sub的記憶體單元釋放*/
    StrDestroy(&S1);
    StrDestroy(&S2);
    StrDestroy(&Sub);
}
void StrPrint(HeapString S)
{
    int i;
    for(i=0;i<S.length;i++)
    {
        printf("%c",S.str[i]);
    }
    printf("\n");
}

• 測試結果