數據結構 | 串的塊鏈存儲表示法

————————————————————————————————————————————

• 串的塊鏈存儲表示法

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

相關要點：

• 通過鏈表方式存儲時給每一個結點的字符數組分配固定的大小（塊），大小可以根據需要手動調節，#define CHUNKSIZE 4 //塊大小。
• 由於串長不一定是結點大小的整倍數，所以鏈表的最后一個結點不一定被字符占滿，未滿的位置使用#符號補全
• 定義頭指針和尾指針指向鏈表，並給出一個變量存儲鏈表的長度。設立尾指針的目的是為了便於進行聯結操作。
• 在鏈式存儲方式中，結點大小的選擇影響着串處理的效率。注意串值的存儲密度，存儲密度 = 串值所占的存儲位/實際分配的存儲位。
• 串值的鏈式存儲結構對聯結操作有方便之處，但總體上不如另兩種存儲結構靈活，占用存儲量大且操作復雜。

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

存儲結構：

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

實現代碼：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OVERFLOW -2
typedef int Status;
/* 存儲結構 */
#define blank '#'
#define CHUNKSIZE 4 //塊大小
typedef struct Chunk
{
    char ch[CHUNKSIZE];
    struct Chunk *next;
} Chunk;
typedef struct
{
    Chunk *head, *rear; //串的頭和尾指針
    int curlen; //串的當前長度
} LString;
/* 函數列表 */
void InitString(LString *T);
Status StrAssign(LString *T, char *chars);
Status StrCopy(LString *T, LString S);
Status StrEmpty(LString S);
int StrCompare(LString S, LString T);
int StrLength(LString S);
Status ClearString(LString *S);
Status Concat(LString *T, LString S1, LString S2);
Status SubString(LString *Sub, LString S, int pos, int len);
int Index(LString S, LString T, int pos);
void Zip(LString *S); //壓縮串
Status StrInsert(LString *S, int pos, LString T);
Status StrDelete(LString *S, int pos, int len);
Status Replace(LString *S, LString T, LString V);
void StrPrint(LString T);
void DestroyString();
/* 主函數 */
int main()
{
    int pos, len, flag;
    char *s1 = "Hello,LString!", *s2 = "Booooo!",  *s3 = "123#4", *s4 = "Hello,LString!!", *s5 = "Insert!", *s6 = "Insert!!", *s7 = "***", *s8 = "o"; //此種賦值方式,最后一個字符結束后,下一個字符位為空,可以通過*s1==NULL判斷字符串結束
    LString t1, t2, t3, t4, t5, t6;
    InitString(&t1); //初始化t1
    InitString(&t2); //初始化t2
    printf("--------------------------\n");
    printf("StrEmpty...OK.\n");
    if(StrEmpty(t1))
        printf("t1 is Empty\n");
    else
        printf("t1 is not Empty\n");
    printf("StrLength...OK.\n");
    printf("length:%d\n", StrLength(t1));
    printf("--------------------------\n");
    printf("StrAssign...OK.\n");
    StrAssign(&t1, s1);
    printf("t1:");
    StrPrint(t1);
    printf("length:%d\n", StrLength(t1));
    StrAssign(&t2, s2);
    printf("t2:");
    StrPrint(t2);
    printf("length:%d\n", StrLength(t2));
    printf("--------------------------\n");
    printf("StrCopy...OK.\n");
    StrCopy(&t3, t1);
    printf("t3:");
    StrPrint(t3);
    printf("--------------------------\n");
    InitString(&t4);
    StrAssign(&t4, s4);
    flag = StrCompare(t1, t4);
    printf("StrCompare...OK.\n");
    StrPrint(t1);
    if (flag == 0)
        printf("==\n");
    else if(flag > 0)
        printf(">\n");
    else if(flag < 0)
        printf("<\n");
    StrPrint(t4);
    printf("--------------------------\n");
    printf("ClearString...OK.\n");
    ClearString(&t3);
    if(StrEmpty(t3))
        printf("t3 is Empty\n");
    else
        printf("t3 is not Empty\n");
    printf("--------------------------\n");
    printf("Concat...OK.\n");
    InitString(&t5);
    Concat(&t5, t1, t2);
    printf("t5:");
    StrPrint(t5);
    printf("length:%d\n", StrLength(t5));
    printf("--------------------------\n");
    printf("StrInsert Insert! ...OK.\n");
    StrAssign(&t3, s5);
    StrInsert(&t5, 21, t3);
    StrPrint(t5);
    printf("length:%d\n", StrLength(t5));
    printf("--------------------------\n");
    printf("StrDelete pos:13 len:5 ...OK.\n");
    StrDelete(&t5, 13, 5);
    StrPrint(t5);
    printf("length:%d\n", StrLength(t5));
    printf("--------------------------\n");
    printf("SubString He ...OK.\n");
    SubString(&t6, t5, 1, 2);
    printf("length:%d\n", StrLength(t6));
    printf("--------------------------\n");
    printf("Index Insert!! ...OK.\n");
    StrPrint(t5);
    ClearString(&t3);
    StrAssign(&t3, s6);
    printf("index pos:%d\n", Index(t5, t3, 1));
    printf("--------------------------\n");
    printf("Replace o -> *** ...OK.\n");
    ClearString(&t3);
    StrAssign(&t3, s7);
    ClearString(&t2);
    StrAssign(&t2, s8);
    Replace(&t5, t2, t3);
    StrPrint(t5);
    printf("--------------------------\n");
    return OK;
}
/* 初始化空串,不分配空間 */
void InitString(LString *T)
{
    T->head = NULL;
    T->rear = NULL;
    T->curlen = 0;
}
Status StrAssign(LString *T, char *chars)
{
    int len, blockNum, i, j;
    Chunk *p, *q;
    len = strlen(chars);
    if (!len || strchr(chars, blank)) //長度為0或包含#時結束
        return ERROR;
    T->curlen = len;
    blockNum = len / CHUNKSIZE; //計算結點數
    if (len % CHUNKSIZE)
        ++blockNum;
    for (i = 0; i < blockNum; ++i) //循環生成新節點
    {
        p = (Chunk *)malloc(sizeof(Chunk));
        if (!p)
            exit(OVERFLOW);
        if (T->head == NULL) //如果是第一個節點
            T->head = q = p;
        else
        {
            q->next = p;
            q = p;
        }
        for (j = 0; j < CHUNKSIZE && *chars; ++j) //每次新增一個塊鏈即賦值,chars指針隨之++,當chars指向空字符時結束
        {
            *(q->ch + j) = *chars;
            ++chars;
        }
        if (!*chars) //當*chars指向空字符(最后一個鏈塊時)
        {
            T->rear = p;
            T->rear->next = NULL;
            for (; j < CHUNKSIZE; ++j) //當chars結束時j的值直接在此處使用
                *(q->ch + j) = blank;
        }
    }
    return OK;
}
Status StrCopy(LString *T, LString S)
{
    //另一個思路:將S中的內容讀到char*中,調用StrAssign();
    Chunk *h = S.head, *p, *q;
    if (!h)
        return ERROR;
    T->head = (Chunk *)malloc(sizeof(Chunk)); //創建頭節點
    p = T->head;
    *p = *h; //將S頭節點的內容復制給T頭節點
    h = h->next;
    while(h)
    {
        q = p;
        p = (Chunk *)malloc(sizeof(Chunk));
        q->next = p;
        *p = *h;
        h = h->next;
    }
    p->next = NULL;
    T->rear = p;
    return OK;
}
Status StrEmpty(LString S)
{
    if (!S.curlen)
        return TRUE;
    else
        return FALSE;
}
int StrCompare(LString S, LString T)
{
    int i = 0;
    Chunk *ps = S.head, *pt = T.head;
    while(ps && pt) //當有一個節點指向NULL時結束循環
    {
        for (i = 0; i < CHUNKSIZE; ++i) //節點內遍歷
        {
            if (*(ps->ch + i) != *(pt->ch + i)) //如果指向的元素不同,則返回相減結果
            {
                if (*(ps->ch + i) == blank)
                    return -1;
                else if (*(pt->ch + i) == blank)
                    return 1;
                return *(ps->ch + i) - *(pt->ch + i);
            }
        }
        ps = ps->next; //該節點對比結束,進入下一節點對比
        pt = pt->next;
    }
    return ps - pt; //當有一個指向NULL時,該指針為0,返回相減結果即可
}
// int StrCompare(LString S, LString T) //書上源碼
// {
//     /* 若S>T,則返回值>0;若S=T,則返回值=0;若S<T,則返回值<0 */
//     int i = 0; /* i為當前待比較字符在S,T串中的位置 */
//     Chunk *ps = S.head, *pt = T.head; /* ps,pt分別指向S和T的待比較塊 */
//     int js = 0, jt = 0; /* js,jt分別指示S和T的待比較字符在塊中的位序 */
//     while(i < S.curlen && i < T.curlen)
//     {
//         i++; /* 分別找S和T的第i個字符 */
//         while(*(ps->ch + js) == blank) /* 跳過填補空余的字符 */
//         {
//             js++;
//             if(js == CHUNKSIZE)
//             {
//                 ps = ps->next;
//                 js = 0;
//             }
//         }; /* *(ps->ch+js)為S的第i個有效字符 */
//         while(*(pt->ch + jt) == blank) /* 跳過填補空余的字符 */
//         {
//             jt++;
//             if(jt == CHUNKSIZE)
//             {
//                 pt = pt->next;
//                 jt = 0;
//             }
//         }; /* *(pt->ch+jt)為T的第i個有效字符 */
//         if(*(ps->ch + js) != *(pt->ch + jt))
//             return *(ps->ch + js) - *(pt->ch + jt);
//         else /* 繼續比較下一個字符 */
//         {
//             js++;
//             if(js == CHUNKSIZE)
//             {
//                 ps = ps->next;
//                 js = 0;
//             }
//             jt++;
//             if(jt == CHUNKSIZE)
//             {
//                 pt = pt->next;
//                 jt = 0;
//             }
//         }
//     }
//     return S.curlen - T.curlen;
// }
int StrLength(LString S)
{
    return S.curlen;
}
Status ClearString(LString *S)
{
    Chunk *p, *q;
    if (!S->curlen)
        return ERROR;
    p = S->head;
    while(p)
    {
        q = p->next;
        free(p);
        p = q;
    }
    S->head = NULL;
    S->rear = NULL;
    S->curlen = 0;
    return OK;
}
Status Concat(LString *T, LString S1, LString S2)
{
    LString T1, T2;
    InitString(&T1);
    InitString(&T2);
    StrCopy(&T1, S1);
    StrCopy(&T2, S2);
    T->curlen = S1.curlen + S2.curlen;
    T->head = T1.head;
    T1.rear->next = T2.head;
    T->rear = T2.rear;
    return OK;
}
void StrPrint(LString T)
{
    Chunk *p;
    p = T.head;
    int i;
    while(p)
    {
        for (i = 0; i < CHUNKSIZE; ++i)
            if (*(p->ch + i) != blank)
                printf("%c", *(p->ch + i));
        p = p->next;
    }
    printf("\n");
}
void DestroyString() //無法銷毀
{
    ;
}
Status StrInsert(LString *S, int pos, LString T) //書上源碼
{
    /* 1≤pos≤StrLength(S)+1。在串S的第pos個字符之前插入串T */
    int i, j, k;
    Chunk *p, *q;
    LString t;
    if(pos < 1 || pos > StrLength(*S) + 1) /* pos超出范圍 */
        return ERROR;
    StrCopy(&t, T); /* 復制T為t */
    Zip(S); /* 去掉S中多余的填補空余的字符 */
    i = (pos - 1) / CHUNKSIZE; /* 到達插入點要移動的塊數 */
    j = (pos - 1) % CHUNKSIZE; /* 到達插入點在最后一塊上要移動的字符數 */
    p = (*S).head;
    if(pos == 1) /* 插在S串前 */
    {
        t.rear->next = (*S).head;
        (*S).head = t.head;
    }
    else if(j == 0) /* 插在塊之間 */
    {
        for(k = 1; k < i; k++)
            p = p->next; /* p指向插入點的左塊 */
        q = p->next; /* q指向插入點的右塊 */
        p->next = t.head; /* 插入t */
        t.rear->next = q;
        if(q == NULL) /* 插在S串后 */
            (*S).rear = t.rear; /* 改變尾指針 */
    }
    else /* 插在一塊內的兩個字符之間 */
    {
        for(k = 1; k <= i; k++)
            p = p->next; /* p指向插入點所在塊 */
        q = (Chunk *)malloc(sizeof(Chunk)); /* 生成新塊 */
        for(i = 0; i < j; i++)
            *(q->ch + i) = blank; /* 塊q的前j個字符為填補空余的字符 */
        for(i = j; i < CHUNKSIZE; i++)
        {
            *(q->ch + i) = *(p->ch + i); /* 復制插入點后的字符到q */
            *(p->ch + i) = blank; /* p的該字符為填補空余的字符 */
        }
        q->next = p->next;
        p->next = t.head;
        t.rear->next = q;
    }
    (*S).curlen += t.curlen;
    Zip(S);
    return OK;
}
// Status StrInsert(LString *S, int pos, LString T) //插入字符串操作,有BUG
// {
//     //在塊之間插入新的字符串,並利用zip壓縮將串中多余的#去處
//     int i, j, insertPos, blockPos;
//     if (pos >= S->curlen) //如果pos越界,則定位在頭或尾位置
//         pos = S->curlen + 2;
//     else if (pos <= 0)
//         return ERROR;
//     Chunk *h = S->head, *p, *q;
//     insertPos = pos % CHUNKSIZE; //確定塊中要插入的位置
//     if (pos % CHUNKSIZE == 0) //如果插入的位置是塊之間
//     {
//         blockPos = pos / CHUNKSIZE; //定位要插入塊的位置
//         q = S->head; //q指向頭結點
//         for (i = blockPos; i > 1; --i) //q指向正在被分開的塊
//             q = q->next;
//     }
//     else //如果是塊中
//     {
//         blockPos = (pos / CHUNKSIZE) + 1; //定位塊
//         //將塊要插入的位置前后分離
//         p = (Chunk *)malloc(sizeof(Chunk)); //申請一個新的結點,將插入點后的半個結點挪過去
//         q = S->head; //q指向頭結點
//         for (i = blockPos; i > 1; --i) //q指向正在被分開的塊
//             q = q->next;
//         j = i = CHUNKSIZE - (pos % CHUNKSIZE); //使用i,j來存儲需要挪的個數(該結點從后往前數)
//         for (; i > 0; --i) //將有效字符挪到新節點中,對應原結點中的位置為#
//         {
//             *(p->ch + CHUNKSIZE - i) = *(q->ch + CHUNKSIZE - i);
//             *(q->ch + CHUNKSIZE - i) = blank;
//         }
//         for (; j < CHUNKSIZE; ++j)
//             *(p->ch + CHUNKSIZE - j - 1) = blank;
//         p->next = q->next; //將結點重新連接起來
//         q->next = p;
//     }
//     //此時需要在q之后插入新節點即可,插入完畢后壓縮
//     T.rear->next = q->next;
//     q->next = T.head;
//     S->curlen += T.curlen;
//     Zip(S);
//     return OK;
// }
void Zip(LString *S) //壓縮串
{
    int i, j = 0;
    char *q; //將字符串讀入*q
    q = (char *)malloc(((*S).curlen + 1) * sizeof(char));
    Chunk *p = S->head;
    while(p)
    {
        for (i = 0; i < CHUNKSIZE; ++i)
            if (*(p->ch + i) != blank)
            {
                *(q + j) = *(p->ch + i);
                j++;
            }
        p = p->next;
    }
    *(q + j) = 0; //串結束符
    ClearString(S); //清空字符串S
    StrAssign(S, q); //將讀入的字符串重新賦值給S
}
Status StrDelete(LString *S, int pos, int len) //刪除長度為len的子串,將被刪除的位置替換成為#再壓縮即可
{
    if (pos > S->curlen || pos < 1 || pos + len > S->curlen)
        return ERROR;
    Chunk *p, *q;
    int i, j = 0, n = 0;
    p = S->head;
    pos--;
    while(n < pos)
    {
        j++;
        if (j == CHUNKSIZE)
        {
            p = p->next;
            j = 0;
        }
        n++;
    }
    while(n < pos + len)
    {
        *(p->ch + j) = blank;
        j++;
        if (j == CHUNKSIZE)
        {
            p = p->next;
            j = 0;
        }
        n++;
    }
    Zip(S);
    return OK;
}
Status SubString(LString *Sub, LString S, int pos, int len) //返回某位置長度為len的子串
{
    Chunk *p;
    char *q;
    if (pos > S.curlen || pos < 0 || pos + len - 1 > S.curlen)
        return ERROR;
    q = (char *)malloc((len + 1) * sizeof(char));
    int i = 0, j = 0, n;
    p = S.head;
    while(j < pos) //逐個位置索引到pos
    {
        if (j == pos - 1)
            break;
        ++j;
        ++i;
        if (i == CHUNKSIZE)
        {
            p = p->next;
            i = 0;
        }
    }
    j = 0;
    while(j < len) //逐個位置賦值
    {
        *(q + j) = *(p->ch + i);
        i++;
        if (i == CHUNKSIZE)
        {
            p = p->next;
            i = 0;
        }
        j++;
    }
    *(q + j) = 0;
    InitString(Sub); //初始化子串
    StrAssign(Sub, q); //將q中賦值
    Sub->curlen = len;
    return OK;
}
// Status SubString(LString *Sub, LString S, int pos, int len) //書上源碼
// {
//     /* 用Sub返回串S的第pos個字符起長度為len的子串。 */
//     /* 其中,1≤pos≤StrLength(S)且0≤len≤StrLength(S)-pos+1 */
//     Chunk *p, *q;
//     int i, k, n, flag = 1;
//     if(pos < 1 || pos > S.curlen || len < 0 || len > S.curlen - pos + 1)
//         return ERROR;
//     n = len / CHUNKSIZE; /* 生成空的Sub串 */
//     if(len % CHUNKSIZE)
//         n++; /* n為塊的個數 */
//     p = (Chunk *)malloc(sizeof(Chunk));
//     (*Sub).head = p;
//     for(i = 1; i < n; i++)
//     {
//         q = (Chunk *)malloc(sizeof(Chunk));
//         p->next = q;
//         p = q;
//     }
//     p->next = NULL;
//     (*Sub).rear = p;
//     (*Sub).curlen = len;
//     for(i = len % CHUNKSIZE; i < CHUNKSIZE; i++)
//         *(p->ch + i) = blank; /* 填充Sub尾部的多余空間 */
//     q = (*Sub).head; /* q指向Sub串即將復制的塊 */
//     i = 0;  //i指示即將復制的字符在塊中的位置
//     p = S.head; /* p指向S串的當前塊 */
//     n = 0; /* n指示當前字符在串中的序號 */
//     while(flag)
//     {
//         for(k = 0; k < CHUNKSIZE; k++) /* k指示當前字符在塊中的位置 */
//             if(*(p->ch + k) != blank)
//             {
//                 n++;
//                 if(n >= pos && n <= pos + len - 1) /* 復制 */
//                 {
//                     if(i == CHUNKSIZE)
//                     {
//                         /* 到下一塊 */
//                         q = q->next;
//                         i = 0;
//                     }
//                     *(q->ch + i) = *(p->ch + k);
//                     i++;
//                     if(n == pos + len - 1) /* 復制結束 */
//                     {
//                         flag = 0;
//                         break;
//                     }
//                 }
//             }
//         p = p->next;
//     }
//     return OK;
// }
int Index(LString S, LString T, int pos) //在S中索引子串T
{
    int i, j;
    LString sub;
    if (pos < 1 || pos > S.curlen - T.curlen)
        return ERROR;
    while(pos <= S.curlen - T.curlen + 1)
    {
        SubString(&sub, S, pos, T.curlen);
        if (StrCompare(sub, T) == 0)
            return pos;
        else
            ++pos;
    }
    return ERROR;
}
Status Replace(LString *S, LString T, LString V) //將S中的T替換成V
{
    if (StrEmpty(T))
        return ERROR;
    int pos = 1;
    do
    {
        pos = Index(*S, T, pos);
        if (pos)
        {
            StrDelete(S, pos, T.curlen);
            StrInsert(S, pos, V);
            pos += V.curlen;
        }
    }
    while(pos);
    return OK;
}

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

運行結果：