数据结构学习——串

串即字符串，是由零个或多个字符组成的有限序列。

一、串的存储结构

1. 串的线性存储

//静态定义
#define MAXLEN 255      //预定义最大串长为255
typedef struct{
    char ch[MAXLEN];
    int length;
}SString;

//动态定义
typedef struct{
    char *ch;           //按串长分配存储区，ch指向串的基地址
    int length;
}HString;

HString S;
S.ch=(char *)malloc(MAXLEN*sizeof(char));
S.length=0;

2. 串的链式存储

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

上述代码存储密度低，每个字符所占空间1B，每个指针所占空间4B

提高存储密度的方法：

typedef struct StringNode{
    char ch[4];    //每个结点存多个字符
    struct StringNode *next;
}StringNode,*String;

3. 求子串。用sub返回串S的第pos个字符起长度为len的子串

bool SubString(SString &Sub,SString S,int pos,int 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;
}

4. 字符串比较操作

//当S>T时，返回值>0，S==T时，返回值=0，S<T时，返回值<0
int StrCompare(SString S,SString T){
    for(int i=0;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;
}

5. 子串查找，若主串S中存在与串T值相同的子串，则返回它在主串S中第一次出现的位置；否则函数值为0

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;
}

二、KMP算法

1. 求解next数组

如上图所示，子串的最后一个字符匹配失败时，证明前6个字符是匹配成功的，

重新查找时，若回到子串最前端将会损耗时间，优化方法是：寻找匹配成功的字符串中，包含首字符（不包含尾字符）与包含尾字符（不包含首字符）的最长相同子串

next[j]=S的最长相等前后缀长度+1   next[0]=0

要求next数组，需要两个指针，第一个指针i串的后缀，第二个指针j代表串的前缀，当S[i]=S[j]时，next[i+1]=next[i]+1，当S[i]!=S[j]时，循环往前找能对应的子串，直到j=0

void get_next(SString T,int next[]){
    int i=1,j=0;
    next[i]=0;
    while(i<T.length){
        if(j==0||T.ch[i]==T.ch[j]){
            i++;
            j++;
            next[i]=j;
        }else{
            j=next[j];
        }
    }
}

2. KMP算法

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