數據結構 | 實現串（定長順序存儲表示法）

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

• 定長順序存儲表示法

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

存儲結構：

使用字符串數組作為存儲，定義字符串數組長度為MAXSTRLEN+1（0位置用來存放字符串長度）

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

操作方法：

• 字符串賦值

  通過將控制台輸入的字符串賦值給串S1（從1開始存儲），如果字符串長度超過限制，則截取越界前的數據存入。S1[0]位置存放字符串長度

• 字符串拷貝

  對字符串遍歷逐個拷貝（判斷長度，僅拷貝長度范圍內的）

• 字符串判空

  判斷字符串0位置是否為0

• 返回字符串長度

  返回字符串0位置的值

• 打印字符串

  在字符串長度范圍內遍歷並打印

• 清空字符串

  字符串長度S[0]置為0

• 字符串聯接

  判斷聯接的兩個字符串長度之和，如果長度之和在界限范圍內，則字符串2接到字符串1后。

  如果長度之和超過界限，進行截斷。先存入字符串1，字符串1存入剩下的位置存字符串2。（如果字符串1本身就是界限長度，則留給字符串2的位置為空，不存入字符串2）

• 索引子串位置

  定義兩個臨時變量 i 和 j 存放指向子串和主串的位置。操作如圖所示

  

• 插入子串

  如果插入子串長度會越界，則把原來的尾部擠出字符串范圍，先從字符串尾部開始遍歷后挪，當控制要插入的位置后將要插入的子串賦值給空位。

• 刪除子串

  判斷輸入的位置和長度，將刪除的字符串后面的字符往前挪。

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

實現代碼：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OVERFLOW -2
typedef int Status;
#define MAXSTRLEN 40 //在255范圍內定義最大串長(255為1個字節)
typedef char SString[MAXSTRLEN + 1]; //位置0存放串的長度
/*********************************************************/
Status StrAssign(SString T, char *chars); //字符串賦值
Status StrCopy(SString T, SString S); //字符串拷貝
Status StrEmpty(SString S); //字符串判空
Status StrLength(SString S); //返回字符串長度
Status StrPrint(SString T); //打印字符串
Status ClearString(SString S); //清空字符串
Status Concat(SString T, SString S1, SString S2); //字符串聯結
Status Index(SString T, SString S); //索引子串位置
Status StrInsert(SString T, SString S, int pos); //插入子串
Status StrDelete(SString S, int pos, int len); //刪除某個位置長度為len的子串
/*自己寫的方法,傳入兩個字符串進行比較,如果完全匹配則相同,不完全匹配則判斷是否為子串*/
Status StrCompare(SString T, SString S); //字符串比較
Status StrSubString(SString longStr, SString shortStr); //匹配子串
/*********************************************************/
int main()
{
    SString S1, S2, S3, S4, T;
    char str[MAXSTRLEN];
    int pos, len;
    printf("Input S1:");
    gets(str); //scanf無法讀取到空格
    printf("----------------------------------\n");
    StrAssign(S1, str);//將輸入的str賦值給串S1
    printf("str[40]:%s\n", str);
    StrPrint(S1);
    printf("Length:%d\n", StrLength(S1));
    // printf("S1:%s\n", S1 + 1); //跳過S1[0]打印
    printf("----------------------------------\n");
    StrCopy(S2, S1);
    printf("StrCopy... OK.\n");
    printf("S2:");
    StrPrint(S2);
    printf("S2.len:%d\n", StrLength(S2));
    printf("----------------------------------\n");
    ClearString(S2);
    StrEmpty(S2);
    printf("----------------------------------\n");
    printf("Input S3:");
    gets(str);
    StrAssign(S3, str);
    printf("StrCompare... OK.\n");
    StrCompare(S3, S1);
    printf("----------------------------------\n");
    Concat(S4, S1, S3);
    printf("Concat... OK.\n");
    printf("S4:");
    StrPrint(S4);
    printf("Length:%d\n", StrLength(S4));
    printf("----------------------------------\n");
    printf("Index S4... OK.\n");
    printf("Input index str:");
    gets(str);
    StrAssign(T, str);
    Index(T, S4);
    printf("----------------------------------\n");
    printf("Input Position:");
    scanf("%d", &pos);
    printf("Insert str to S4... OK.\n");
    StrInsert(T, S4, pos);
    printf("S4:");
    StrPrint(S4);
    printf("Length:%d\n", StrLength(S4));
    printf("----------------------------------\n");
    printf("Input Position and Length:");
    scanf("%d %d", &pos, &len);
    StrDelete(S4, pos, len);
    printf("S4:");
    StrPrint(S4);
    printf("Length:%d\n", StrLength(S4));
    return 0;
}
/* 字符串賦值,當賦值字符串長度超過被賦值字符串時候截斷,未超過時先將長度存入T[0],再逐位賦值 */
Status StrAssign(SString T, char *chars)
{
    int i;
    if (strlen(chars) > MAXSTRLEN)
    {
        for (i = 1; i <= MAXSTRLEN; ++i)
            T[i] = *(chars + i - 1);
        T[0] = MAXSTRLEN;
    }
    else
    {
        T[0] = strlen(chars); //p.s.此時T[0]存入的是int類型的數據,打印%s時無法顯示
        for (i = 1; i <= MAXSTRLEN; ++i)
            T[i] = *(chars + i - 1);
        return OK;
    }
}
/* 字符串拷貝,逐個字符拷貝(僅拷貝長度范圍內的) */
Status StrCopy(SString T, SString S)
{
    int i;
    //p.s.此處要拷貝長度+1,將S1的\0同時拷貝進去,否則T中沒有\0
    for (i = 1; i <= S[0]; ++i)
        T[i] = S[i];
    T[0] = S[0];
    return OK;
}
/* 字符串判空,當S[0]==0時為空 */
Status StrEmpty(SString S)
{
    if (S[0] == 0)
    {
        printf("String is Empty\n");
        return TRUE;
    }
    else
    {
        printf("String is not Empty\n");
        return FALSE;
    }
}
/* 返回子串長度 */
Status StrLength (SString S)
{
    return S[0];
}
/* 打印字符串 */
Status StrPrint(SString T)
{
    int i;
    for (i = 1; i <= T[0]; ++i)
    {
        printf("%c", T[i]);
    }
    printf("\n");
    return OK;
}
/* 清空字符串 */
Status ClearString(SString S)
{
    S[0] = 0;
    return OK;
}
/* 字符串聯接,通過T來存儲結果,S2連接而成的新串,若未截斷則返回TRUE,截斷返回FAlSE,注意字符串數組越界問題 */
Status Concat(SString T, SString S1, SString S2)
{
    int i;
    if (S1[0] + S2[0] <= MAXSTRLEN)
    {
        for (i = 1; i <= S1[0]; ++i)
            T[i] = S1[i];
        for (i = 1; i <= S2[0]; ++i)
            T[i + S1[0]] = S2[i];
        T[0] = S1[0] + S2[0];
        return TRUE;
    }
    else //先存完S1中的,再存S2中的內容,條件是不能越界
    {
        for (i = 1; i <= S1[0] && i <= MAXSTRLEN - 1; ++i)
            T[i] = S1[i];
        for (i = 1; i <= MAXSTRLEN - S1[0]; ++i)
            T[i + S1[0]] = S2[i];
        T[0] = MAXSTRLEN;
        return FALSE;
    }
}
/* 索引子串 */
Status Index(SString T, SString S)
{
    int i = 1, j = 1;
    while(j <= T[0] && i <= S[0])
    {
        if (T[j] == S[i])
        {
            ++i;
            ++j;
        }
        else
        {
            i = i - j + 2;
            j = 1;
        }
    }
    if (j > T[0])
    {
        printf("Position:%d\n", i - j + 1);
        return OK;
    }
    else
    {
        printf("substring is not exist\n");
        return ERROR;
    }
}
/* 在位置pos處插入子串T */
Status StrInsert(SString T, SString S, int pos)
{
    int i;
    if (pos > S[0])
        pos = S[0] + 1;
    if (S[0] + T[0] <= MAXSTRLEN)
    {
        for (i = S[0] + T[0]; i >= pos + T[0]; --i)
            S[i] = S[i - T[0]];
        for (i = 1; i <= T[0]; ++i)
            S[pos + i - 1] = T[i];
        S[0] = S[0] + T[0];
        return OK;
    }
    else
    {
        for (i = MAXSTRLEN; i >= pos + T[0]; --i)
            S[i] = S[i - T[0]];
        for (i = 1; i <= T[0]; ++i)
            S[pos + i - 1] = T[i];
        S[0] = MAXSTRLEN;
        return ERROR;
    }
}
Status StrDelete(SString S, int pos, int len)
{
    int i;
    if (pos > S[0])
        return ERROR;
    else if (pos + len > S[0])
        len = S[0] - pos + 1;
    for (i = pos + len; i <= S[0]; ++i)
        S[i - len] = S[i];
    S[0] -= len;
}
/* 字符串比較。比較字符串是否完全相同,如果不同則判斷子串所在的位置 */
Status StrCompare(SString T, SString S)
{
    int i, j;
    /* 當兩個字符串長度相同時,逐個判斷字符是否相同,不相同則退出,相同則繼續比較 */
    if (T[0] == S[0])
    {
        for (i = 1; i <= S[0]; ++i)
        {
            if (T[i] != S[i])
            {
                printf("A.len==B.len , A!=B \n");
                return ERROR;
            }
        }
        printf("A == B\n");
        return OK;
    }
    else if(T[0] < S[0])
        StrSubString(T, S);
    else if(T[0] > S[0])
        StrSubString(S, T);
}
/* 判斷A是否是B的子串。逐個遍歷長字符串,當短字符串首字符與長字符串字符相同時,短字符串與長字符串逐個比較,中途有不匹配的情況則重新開始比較,長字符串繼續遍歷，如果短字符串比對完並且最后一個字符也相同時則是子串 */
Status StrSubString(SString shortStr, SString longStr)
{
    int i, j = 1;
    for (i = 1; i <= longStr[0]; ++i)
    {
        if (shortStr[1] == longStr[i])
        {
            for (j = 1; j <= shortStr[0] ; ++j)
            {
                if (j == shortStr[0] && shortStr[j] == longStr[j + i - 1])
                {
                    printf("A is substring of B.Location is:%d\n", i);
                    return OK;
                }
                if (shortStr[j] != longStr[j + i - 1])
                    break;
            }
        }
    }
    printf("A not substring of B\n");
    return ERROR;
}