第四章——串

串

理论

书本代码

顺序结构

1. 定义静态数组

typedef struct {
    char ch[MAXLEN];
    int length;
}SString;

1.1. 用Sub返回字符串S第pos个字符起长度为len的子串

bool SubString(SString &Sub, SString S, int pos, int len){
    //用Sub返回字符串S第pos个字符起长度为len的子串
    if(pos+len-1 > S.length)
        return false;
    for(int i = pos; i<pos+len; i++)
        Sub.ch[i-pos+1] = S.ch[i];
    Sub.length = len;
    return true;
}

1.2. 比较两个串

int StrCompare(SString S, SString T){
    for (int i = 1; i <= S.length && i <= T.length; i++) {
        if(S.ch[i] != T.ch[i])
            return S.ch[i] - T.ch[i];
    }
    return S.length - T.length;
}

1.3. 求串在主串中的位置

int Index(SString S, SString T){
    int i=1, n=S.length, m=T.length;
    SString sub;
    while (i <= n-m+1){
        SubString(sub, S, i, m);
        if(StrCompare(sub, T) != 0)
            ++i;
        else return i;
    }
    return 0;
}

2. 定义动态数组

typedef struct {
    char *ch;
    int length;
}HString;

2.1. 初始化动态数组

void InitList(HString &S){
    S.ch = (char *) malloc(MAXLEN * sizeof(char));
    S.length = 0;
}

链式存储

1. 定义链式存储

typedef struct StringNode{
    char ch[4];
    struct StringNode *next;
}StringNode,*String;

朴素模式匹配算法

若模式串长度为m，主串长度为n，则

1. 匹配成功的最好时间复杂度：O(m)
2. 匹配失败的最好时间复杂度：O(n-m+1)=O(n-m)=O(n)
3. 直到匹配成功/匹配失败最多需要 (n-m+1)*m 次比较，所以最坏时间复杂度：O(nm)

int index(SString S, SString T){
    int i = 1, j = 1;
    while (i <= S.length && j <= T.length){
        if(S.ch[i] == T.ch[j]){
            ++i;
            ++j;
        }else{
            i = i - j + 2;
            j = 1;
        }
    }
    if(j > T.length)
        return i-T.length;
    else
        return 0;
}