数据结构与算法·第4章【串】

串是有限长的字符序列，由一对单引号相括，如: “a string”
可以理解为c++的$string$

基本操作

$StrAssign,StrCompare,StrLength,Concat,SubString$是基本操作集

定长顺序存储表示

  #define  MAXSTRLEN  255  // 用户可在255以内定义最大串长
  typedef unsigned char Sstring[MAXSTRLEN + 1];   // 0号单元存放串的长度

就是用了char数组模拟string，只不过在数组首位放了数组长度
串的实际长度可在这个予定义长度的范围内随意设定，超过予定义长度的串值则被舍去，称之为“截断”

基本操作

Status SubString(SString &Sub, SString S, int pos, int len) {
    
    
    // 用Sub返回串S的第pos个字符起长度为len的子串。
    //其中，1≤pos≤StrLength(S)且0≤len≤StrLength(S)-//pos+1 。
    if ( pos<1 ||  pos>S[0] || len<0 || len>S[0]-pos+1 )
             return ERROR;
    Sub[1..len] = S[pos..pos+len-1];
    Sub[0] = len;           return OK;
}//SubString

注意S[0]-pos+1这里需要+1

堆分配存储表示

typedef struct {
    
    
   char *ch;      // 若是非空串，则按串长分配存储区，否则ch为NULL
   int  length;   // 串长度
} HString;

通常，C语言中提供的串类型就是以这种存储方式实现的。系统利用函数malloc( )和free( )进行串值空间的动态管理，为每一个新产生的串分配一个存储区，称串值共享的存储空间为“堆”。C语言中的串以一个空字符为结束符， 串长是一个隐含值。简而言之：通过malloc()，free()为串动态分配存储空间

基本操作

Status StrInsert(HString &S, int pos, HString T) {
    
    
      // 1≤pos≤StrLength(S)+1。
       //在串S的第pos个字符之前插入T
      if (pos<1 || pos>S.length+1 ) return ERROR; 
      // pos不合法
      if (T.length) {
    
    
      //T非空，则重新分配空间，插入T 
      if (!(S.ch = (char *) realloc ( S.ch, ( S.length+T.length ) * sizeof ( char ))))
          exit (OVERFLOW);
      for ( i=S.length-1;i>=pos-1; --i)
      //为插入T而腾出位置
      S.ch[i+T.length] = S.ch[i];
      S.ch[pos-1..pos+T.length-2] = T.ch[0..T.length-1]；   //插入T
      S.Length += T.length;
   }
   return OK;
} // StrInsert

注意这一步中的S.ch[pos-1..pos+T.length-2]，感觉这些细节其实不那么能注意到
这里i=S.length-1，是因为：pos给出的视角是数组从1开始到$length$的存储$[1]\dots \dots [length]$，而实际上堆分配的串的存储应该是从0开始的$[0]\dots \dots [length-1]$

$realloc()$

• 如果 size 的值为 0，则等价于调用 free(ptr)，即释放 ptr 所指向的内存空间。
• 如果传入的 ptr 不为 NULL，并且 size 大于原先分配的内存大小，则尝试将之前分配的内存空间扩展为 size 字节的大小。如果当前内存不足以扩展到 size 字节，则重新分配一块新的内存空间，并将原有空间中的数据复制到新的内存空间上，最后释放原有的内存空间，返回新的内存空间的地址。
• 如果传入的 ptr 不为 NULL，并且 size 小于或等于原先分配的内存大小，则尝试缩小原有的内存空间到指定的大小。如果原有的内存空间过大，多余的部分会被返回给内存管理系统。

Status SubString(HString& Sub, HString S, int pos, int len) {
    
    
    // 用 Sub 返回串 S 的第 pos 个字符起长度为 len 的子串
    if (pos < 1 || pos > S.length || len < 0 || len > S.length - pos + 1) return ERROR;
    if (Sub.ch) free(Sub.ch); // 释放旧空间
    if (!len) {
    
    
        Sub.ch = NULL;
        Sub.length = 0; // 空子串
    } else {
    
    
        Sub.ch = (char*)malloc(len * sizeof(char)); // 完整子串
        for (int i = 0; i < len; i++) Sub.ch[i] = S.ch[pos + i - 1];
        Sub.length = len;
    }
    return OK;
} // SubString

仍然要强调的是，注意特殊情况进行特殊判断

串的块链存储表示

链表来存储串值，由于串的数据元素是一个字符，因此用链表存储时，通常一个结点中可以存放一个字符，也可以存放多个字符。

#define CHUNKSIZE 80  // 可由用户定义的块大小
typedef struct Chunk {
    
    
    char ch[CHUNKSIZE];
    struct Chunk* next;
} Chunk;
typedef struct {
    
    
    Chunk *head, *tail; // 串的头和尾指针
    int curlen;         // 串的当前长度
} LString;

实际应用时，可以根据问题所需来设置结点的大小。
例如: 在编辑系统中，整个文本编辑区可以看成是一个串，每一行是一个子串，构成一个结点。即: 同一行的串用定长结构(80个字符), 行和行之间用指针相联接。

串的模式匹配算法

朴素模式匹配

int Index(SString S, SString T, int pos) {
    
    
    // 返回子串 T 在主串 S 中第 pos 个字符之后的位置。若不存在，
    // 则函数值为 0。其中，T 非空，1 <= pos <= StrLength(S)。
    i = pos;
    j = 1;
    while (i <= S[0] && j <= T[0]) {
    
     // 0 下标存储字符串长度
        if (S[i] == T[j]) {
    
     
            ++i;  
            ++j; // 继续比较后继字符
        } else {
    
     
            i = i - j + 2;   
            j = 1; // 指针后退重新开始匹配
        }
    }
    if (j > T[0]) return i - T[0];
    else return 0;
} // Index

关于 $i=i-j+2$ 的含义：当在匹配中出现了不匹配的情况时，我们需要将指针 $i$ 和 $j$ 同时后移一位再进行匹配，以尝试匹配剩下的部分。由于当前指针 i 已经匹配过了前$j-1$个字符，因此需要将 i 前移 j $-1$ 位，再加上 $2$，即可保证$i$恰好后移一位，准备与$j$ 再次匹配。

这种位置类的细节，完全值得好好注意虽然暂时还不知道考试会不会扣这方面的细节，但是自己写代码的时候，也需要避免越界访问

时间复杂度为：O(m*n)

KMP算法

int Index_KMP(SString S, SString T, int pos) {
    
    
    // 利用模式串 T 的 next 函数求 T 在主串 S 中第 pos 个字符之后的位置的 KMP 算法。
    // 其中，T 非空，1 ≤ pos ≤ StrLength(S)
    int next[MAXSIZE];
    GetNext(T, next);
    int i = pos;
    int j = 1;
    while (i <= S[0] && j <= T[0]) {
    
     // 0 下标存储字符串长度
        if (j == 0 || S[i] == T[j]) {
    
     
            ++i;  
            ++j; // 继续比较后继字符
        } else {
    
    
            j = next[j]; // 模式串向右移动
        }
    }
    if (j > T[0]) {
    
    
        return i - T[0] + 1; // 匹配成功
    } else {
    
    
        return 0;
    }
} // Index_KMP

这个算法稍微有点复杂
讲解
其中，考试$next$数组要自己弄出来

void GetNext(SString T, int* next) {
    
    
    int i = 1;
    int j = 0;
    next[1] = 0;

    while (i < T[0]) {
    
    
        if (j == 0 || T[i] == T[j]) {
    
    
            ++i;
            ++j;
            next[i] = j;
        } else {
    
    
            j = next[j];
        }
    }
}

习题

KMP匹配