23考研王道串（第四章）自用笔记

• 串，即字符串（String）是由零个或多个字符组成的有限序列。一般记为S = ‘a₁a₂······a_n’（n≥0），其中，S是串名，单引号括起来的字符序列是串的值；a_i可以是字母、数字或其他字符；串中字符的个数n称为串的长度。n = 0时的串称为空串（用∅表示）。串的下标从1开始。
• 子串：串中任意个连续的字符组成的子序列。
• 主串：包含子串的串。
• 字符在主串中的位置：字符在串中的序号。
• 子串在主串中的位置：子串的第一个字符在主串中的位置 。
• 空串：M=‘’（里面什么都没有）
• 空格串：M=" "（三个空格）

• 串的逻辑结构：线性表
  

• 串的数据对象限定为字符集（如中文字符、英文字符、数字字符、标点字符等）
• 串的基本操作，如增删改查等通常以子串为操作对象

（1）StrAssign(&T,chars)：赋值操作。把串T赋值为chars。
（2）StrCopy(&T,S)：复制操作。由串S复制得到串T。
（3）StrEmpty(S)：判空操作。若S为空串，则返回TRUE，否则返回FALSE。
（4）StrLength(S)：求串长。返回串S的元素个数。
（5）ClearString(&S)：清空操作。将S清为空串。
（6）DestroyString(&S)：销毁串。将串S销毁（回收存储空间）。
（7）Concat(&T,S1,S2)：串联接。用T返回由S1和S2联接而成的新串
（8）SubString(&Sub,S,pos,len)：求子串。用Sub返回串S的第pos个字符起长度为len的子串。
（9）Index(S,T)：定位操作。若主串S中存在与串T值相同的子串，则返回它在主串S中第一次出现的位置；否则函数值为0。
（10）StrCompare(S,T)：比较操作。若S>T，则返回值>0；若S=T，则返回值=0；若S 串的顺序存储结构

//串的定长顺序存储
#define MaxSize 255     //预定义最大串长为255
typedef struct {
    char ch[MaxSize];      //每个分量存储一个字节
    int lenght;                     //串的实际长度
} SString;

//串的堆式顺序存储(动态分配空间)
typedef struct {
    char *ch;       //若是非空串， 则按串长分配存储区， 否则 ch 为 NULL
    int length;     //串的当前长度
} HString;

//初始化
bool InitSString(SString &S) {
    S.lenght = 0;
    return true;
}

//在主串中从第pos个位置往后截取len个长度并赋值给Sub
bool SubString(SString &Sub, SString S, int pos, int len) {
    if (pos + len - 1 > S.lenght) {    //子串的范围越界
        return false;
    }
    for (int i = pos; i < pos + len; i++) {
        Sub.ch[i - pos + 1] = S.ch[i];
    }
    Sub.lenght = len;
    return true;
}
//比较操作。若S>T,则返回值>0;若S=T,则返回值=0;若S
    int len1 = S.lenght;
    int len2 = T.lenght;
    for (int i = 1; i < S.lenght && i < T.lenght; i++) {
        if (S.ch[i] != T.ch[i]) {
            return S.ch[i] - T.ch[i];
        }
    }
    //扫描过的所有字符都相同，则长度长的串更大
    return S.lenght - T.lenght;
}
//定位操作。若主串S中存在与串T值相同的子串，则返回它在主串S中第一次出现的位置；否则函数值为0。
int Index(SString S, SString T) {
    int LenT = T.lenght;
    int LenS = S.lenght;
    int i = 1;
    SString Sub;
    while (i <= LenS - LenT + 1) {
        SubString(Sub, S, i, LenT);        //从第一个位置开始截取LenT长度的子串
        if (StrCompare(T, Sub) != 0) {      //子串Sub和T比较，不等则++i
            ++i;
        } else {
            return i;       //相等则返回位置
        }
    }
    return 0;       //均不等，则没有该子串。
}
//输出
void show(SString S){
    for(int i=1;i<=S.lenght;i++){
        cout<
    SString  S,Sub,T;
    //输入
    if(InitSString(S)){
        string s;
        getline(cin,s);
        for(int i=0;i
            S.ch[i+1]=s[i];		//从1开始
        }
        S.lenght=s.length();
    }
    cout<<"存储的结果为："< 
串的链式存储结构 
由于串结构的特殊性——结构中的每个数据元素是一个字符，则在用链表存储串值时，存在一个 “结点大小＂ 的问题，即每个结点可以存放一个字符，也可以存放多个字符。（增加存储密度）
图 4.3 (a)所示为结点大小为 4 (即每个结点存放 4 个字符） 的链表，图 4.3 (b)所示为结点大小为 1 的链表。 当结点大小大于1时，由于串长不一定是结点大小的整倍数，则链表中的最后一个结点不一定全被串值占满，此时通常补上"#“或其他的非串值字符（通常”#"不属于串的字符集，是一个特殊的符号）。
 
 为了便于进行串的操作，当以链表存储串值时，除头指针外，还可附设一个尾指针指示链表中的最后一个结点，并给出当前串的长度。称如此定义的串存储结构为块链结构，说明如下：
 
链串的定义 
#define ChunkSize 8     //可由用户定义的块大小
typedef struct Chunk {
    char ch[ChunkSize];
    struct Chunk *next;
} Chunk;
typedef struct {
    Chunk *head, *tail;  //串的头和尾指针
    int length;     //／串的当前长度
};
 
链串的其他操作 
其他操作与链表无太大差别，自行实现且参考链表
 
字符串朴素模式匹配算法（两种） 
 
//第一种
//定位操作。若主串S中存在与串T值相同的子串，则返回它在主串S中第一次出现的位置；否则函数值为0。
int Index(SString S, SString T) {
    int LenT = T.lenght;
    int LenS = S.lenght;
    int i = 1;
    SString Sub;
    while (i <= LenS - LenT + 1) {
        SubString(Sub, S, i, LenT);        //从第一个位置开始截取LenT长度的子串
        if (StrCompare(T, Sub) != 0) {      //子串Sub和T比较，不等则++i
            ++i;
        } else {
            return i;       //相等则返回位置
        }
    }
    return 0;       //均不等，则没有该子串。
}
//第二种（BF算法）
int Index_BF(SString S, SString T, int pos) {
    int i = pos;
    int j = 1;
    while (i <= S.lenght && j <= T.lenght) {
        if (S.ch[i] == T.ch[j]) {           //若果相等匹配成功，则两个指针分别后移
            ++i;
            ++j;
        } else {
            i = i - j + 2;       //若果不匹配，i回到开始位置的下一个位置
            j = 1;                  //j从T.ch的第一个位置开始
        }
    }
    if (j > T.lenght) {         //匹配成功
        return i - T.lenght;
    } else {
        return 0;
    }
}
 
BF算法时间复杂度：(设主串⻓度为 n，模式串⻓度为 m)
 O(mn)——最坏
 O(n)——最好
 
字符串KMP算法 
核心：主串指针不变，改变模式串指针（根据next数组）
 
 
next数组计算方法：（next[0]、next[1]无脑写0）
 ①：在不匹配的位置前边，划一根美丽的分界线，模式串一步一步往后退，直到分界线之前“能对上”，或模式串完全跨过分界线为止，此时j指向哪儿，next数组值就是多少。(推荐手动计算)
 
 
②：next数组代码实现方法（分别设置next[1]和next[2]的值为0和1）
 要求i位置next值时，观察前一个位置，即i-1位置。
 (1). 设置一个固定指针指向i-1位置，一个移动指针j首先指向i-1。
 (2). 如果i-1位置的字符和j位置next指向的字符相同，则设置next为j位置next值+1。
 (3). 如果不相同则让j指针移动。移动到目前next指向的位置。直到i-1位置的字符和j位置next指向的字符相同或者j位置next指向0，则设置next为j位置next值+1。
 
int Next(SString T, int next[]) {
    next[1] = 0;
    int i = 1, j = 0;     
    while (i <= T.lenght) {
        if (j == 0 || T.ch[i] == T.ch[j]) {
            next[++i] = ++j;
        } else {
            j = next[j];
        }
    }
}

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