3.2 串的存储结构

3.2.1 串的存储结构

顺序存储和链式存储

3.2.2 串的顺序存储的实现方式

实现方式：静态分配和动态分配，一般用动态分配

串的类型描述：

静态分配：SString

#define MAXLEN 255;			 //定义最大长度
typedef struct{
    char ch[MAXLEN];         //“静态”的数组存数据，存字符
    int length;              //串的实际长度
}SString;

动态分配：HString

typedef struct{
    char *ch;                //指向“动态”分配的串的基地址
    int length;              //顺序表的当前长度
}HString;

静态分配的顺序存储的串的优缺点

缺点：串的顺序存储的表长确定后无法修改，存满了就存不了了

动态分配的顺序表的优缺点：

优点：可以动态增加长度

缺点：动态增加长度中的迁移工作时间开销大

3.2.3 串的链式存储的实现方式

实现方式：不带头结点和带头结点，一般用带头结点

不带头结点和带头结点的类型描述相同，初始化和判空不同

串的类型描述：

分为：单个分配和堆分配，一般用堆分配

单个分配存储密度低，堆分配存储密度高

单个分配：

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

堆分配：

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

3.2.4 串的上的操作

以静态分配的顺序串为主

求子串

//求子串
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;
}

字符串比较

//字符串比较操作。若S>T,则返回值>0;若S=T,则返回值=0;若S<T,则返回值<0。
int StrCompare(SString S, SString T){
    for(int i=1; i<S.length && T.length; i++){
        if(S.ch[i]!=T.ch[i]) return S.ch[i]-T[i];
    }
    //扫描过所有字符都相等，则长度更长的串更大
    return S.length-T.length;
}

定位操作

方法：在S中依次按顺序取m长子串，判断是否与T相同

//定位操作
int Index(SString S,SString T){
    int i = 1, n = StrLength(S), m = StrLength(T);
    SString sub;
    while(i < n-m+1){
        SubString(sub, S, i, m);
        if(StrCompare(sub, T) != 0) ++i;
        else return i; //返回子串在主串中的位置
    }
    return 0;          //S中不存在与T相同的子串
}