4.3 字符串

  字符串(String)是由零个或多个字符(char)顺序排列组成的有限序列，简称为串。例如 “good morning”就是由12个字符构成的一个字符串。一般把字符串记作：

$$S{=}^{\prime \prime }{a}_0{a}_1\dots a_{n-1}^{\prime \prime }$$

  其中S是串名，引号中的字符序列是串值。字符个数是串的长度，长度为0的串被称为空串，因为它不包含任何字符。需要注意的是，空格字符（" "）并不是空串，因为它包含一个字符——空格。
  若把某个串称为主串，则主串中任意个连续的字符组成的子序列被称为子串。子串在主串中第一次出现时，其首字符在主串中的序号被称为该子串在主串中的位置。
  关于字符串的基础知识亦可参考前文：
【重拾C语言】六、批量数据组织（三）数组初值；字符串、字符数组、字符串数组；类型定义 typedef
【重拾C语言】七、指针（三）指针与字符串（字符串与字符串数组；指针与字符串的遍历、拷贝、比较；反转字符串）

4.3.1 字符串的定义与存储

  字符串在许多非数值计算问题中扮演着重要的角色，并在模式匹配、程序编译和数据处理等领域得到广泛应用。在高级程序设计语言中，字符串通常被定义为以特殊字符’\0’（称为空字符或字符串结束符）结尾的字符序列。这个约定使得在处理字符串时可以方便地确定字符串的结束位置。关于字符串的存储方式，主要有两种常见的方式：

• 顺序存储：字符串的字符按照顺序依次存储在连续的内存空间中。这种方式使得字符串的访问和操作效率较高，可以通过索引直接访问任意位置的字符。在顺序存储方式中，字符串的长度可以通过计算字符个数或者遇到’\0’结束符来确定。

• 链式存储：字符串的字符通过链表的方式进行存储。每个节点包含一个字符和指向下一个节点的指针。链式存储方式可以动态地分配内存，适用于长度可变的字符串。但是相比于顺序存储，链式存储方式需要更多的内存空间，并且访问字符需要遍历链表。

  选择何种存储方式取决于具体的应用场景和需求。顺序存储适合于需要频繁访问和操作字符串的情况，而链式存储适合于长度可变的字符串或者对内存空间要求较高的情况。具体C语言实现可参照前文：
  【数据结构】数组和字符串（十一）：字符串的定义与存储（顺序存储、链式存储及其C语言实现）

4.3.2 字符串的基本操作

顺序存储：【数据结构】数组和字符串（十二）：顺序存储字符串的基本操作（串长统计、查找、复制、插入、删除、串拼接）
链式存储：【数据结构】数组和字符串（十三）：链式字符串的基本操作（串长统计、查找、复制、插入、删除、串拼接）

4.3.3 模式匹配算法

  文本编辑器中常用的“查找”、“替换”和“全部替换”等基本的编辑操作就是最普通的模式匹配问题，即：在文本文件中查找串。它的查找过程可简单描述如下：给定两个字符串变量 S 和 P，其中目标串 S 有n个字符，模式串P有m个字符，m≤n . 从S的给定位置（通常为S的第一个字符）开始，搜索模式串P，如果找到，返回模式串P在S中匹配成功的起始位置；如果没找到（即S中没有P），则返回–1 .
  字符串匹配可以采用多种算法，包括朴素模式匹配算法、KMP（Knuth-Morris-Pratt）算法、Boyer-Moore算法等。这些算法的性能和效率各不相同，具体选择取决于应用的需求和文本数据的规模。

1. 算法原理

• 从S的字符$S_0$开始，将P（长度为m）中的字符依次与S中的字符进行比较：
  • 若$S_0=P_0，S_1=P_1，\dots ，S_{m-1}=P_{m-1}$则匹配成功，返回与$P_0$相匹配的字符$S_0$在$S$中的位置（下标为0）；
  • 若某一步，$S_i\ne P_i$，说明此次匹配不成功，以下比较无需进行。
• 于是再从$S$的字符$S_1$开始进行第二次匹配，重复刚才的步骤
  • 看是否有$S_1=P_0，S_2=P_1，\dots ，S_m=P_{m-1}$ 若匹配成功，返回与P0相匹配的字符S1在S中的下标1.
  • 否则从S的字符S2开始进行第三次匹配’
• ……
• 若第$n-m+1$次匹配（即最后一次匹配）仍得不到 $S_{n-m}=P_0，S_{n-m+1}=P_1，\dots ，S_{n-1}=P_{m-1}$,说明匹配失败，返回 -1 .
• 这种模式匹配算法被称为朴素的模式匹配算法，

2. ADL语言

3. 伪代码

function naivePatternMatching(S, P):
    n = length(S)  # 目标串的长度
    m = length(P)  # 模式串的长度

    for i from 0 to n - m:
        j = 0
        while j < m and S[i + j] == P[j]:
            j = j + 1

        if j == m:  # 如果模式串完全匹配
            return i  # 返回匹配位置

    return -1  # 未找到匹配

# 示例用法
S = "ABABCABAB"
P = "ABAB"
result = naivePatternMatching(S, P)
if result != -1:
    print("模式串在目标串中的位置:", result)
else:
    print("未找到匹配")

4. C语言实现

#include <stdio.h>
#include <string.h>

int naivePatternMatching(const char* S, const char* P) {
    int n = strlen(S);  // 目标串的长度
    int m = strlen(P);  // 模式串的长度

    for (int i = 0; i <= n - m; i++) {
        int j = 0;
        while (j < m && S[i + j] == P[j]) {
            j++;
        }

        if (j == m) {  // 如果模式串完全匹配
            return i;  // 返回匹配位置
        }
    }

    return -1;  // 未找到匹配
}

int main() {
    const char* S = "QomolangmaH";
    const char* P = "lang";
//    const char* P = "gan";

    int result = naivePatternMatching(S, P);
    if (result != -1) {
        printf("模式串在目标串中的位置: %d\n", result);
    } else {
        printf("未找到匹配\n");
    }

    return 0;
}

5 时间复杂度

  朴素模式匹配算法的优点是过程简单，缺点是效率低。在最坏情况下，该算法要匹配n-m+1次，每次匹配要做m次比较，因此最坏情况下的比较次数是m×(n-m+1)，时间复杂性为O(m×(n-m+1))，通常情况下，m的值远小于n的值，于是最坏情况下的时间复杂性可粗略地记为O(n×m)。对于长文本和模式串，可能会导致性能问题。因此，有更高效的模式匹配算法，如KMP和Boyer-Moore等，用于更快速地找到匹配位置，具体内容详见后文。