数据结构-字符串详解
shuan本章主要内容：字符串的三种存储方式和两种常见算法。
三种存储结构：
1、定长顺序存储：实际上就是用普通数组（又称静态数组）存储。例如 C 语言使用普通数据存储字符串的代码为 char a[20] = "data.biancheng.net"。
2、堆分配存储：用动态数组存储字符串。
3、块链存储：用链表存储字符串。
两种常见算法：
1、BF算法：串模式匹配算法。
2、KMP算法：快速模式匹配算法。
一、什么是字符串
1、字符串要单独用一种存储结构来存储，称为串存储结构。这里的串指的就是字符串。
2、对一些特殊的串进行的命名，比如说：
空串：存储 0 个字符的串，例如 S = ""（双引号紧挨着）；
空格串：只包含空格字符的串，例如 S = " "（双引号包含 5 个空格）；
子串和主串：假设有两个串 a 和 b，如果 a 中可以找到几个连续字符组成的串与 b 完全相同，则称 a 是 b 的主串，b 是 a 的子串。
注意：空格串和空串不同，空格串中含有字符，只是都是空格而已。另外，只有串 b 整体出现在串 a 中，才能说 b 是 a 的子串，比如 "shujiejugou" 和 "shuju" 就不是主串和子串的关系。
二、三种存储结构
1、定长顺序存储结构
顺序存储的底层实现是顺序表，也就是数组，根据创建方式不同，可分为静态数组和动态数组：通常所说的数组都指的是静态数组，如 str[10]，静态数组的长度是固定的。与静态数组相对应的，还有动态数组，它使用 malloc 和 free 函数动态申请和释放空间，因此动态数组的长度是可变的。
串的定长顺序存储结构，可以简单地理解为采用 "固定长度的顺序存储结构" 来存储字符串，因此限定了其底层实现只能使用静态数组。
使用定长顺序存储结构存储字符串时，需结合目标字符串的长度，预先申请足够大的内存空间。
例如，采用定长顺序存储结构存储 "data.biancheng.net"，通过目测得知此字符串长度为 18，因此我们申请的数组空间长度至少为 19（最后一位存储字符串的结束标志 '\0'），用 C 语言表示为：
char str[19] = "data.biancheng.net";完整静态存储代码：
#include
int main()
{
char str[19]="data.biancheng.net";
printf("%s\n",str);
return 0;
}
2、堆分配存储结构
串的堆分配存储，其具体实现方式是采用动态数组存储字符串。
通常，编程语言会将程序占有的内存空间分成多个不同的区域，拿C语言来说，程序会将内存分为 4 个区域，分别为堆区、栈区、数据区和代码区，与其他区域不同，堆区的内存空间需要程序员手动使用 malloc 函数申请，并且在不用后要手动通过 free 函数将其释放。
C 语言中使用 malloc 函数最多的场景是给数组分配空间，这类数组称为动态数组。例如：
char *str=(char*)malloc(6*sizeof(char));此代码创建了一个动态数组str，通过malloc申请了6个char类型大小的堆存储空间。动态数组相比普通数组（静态数组）的优势是长度可变，换句话说，根据需要动态数组可额外申请更多的堆空间（使用 relloc 函数）：
str=(char*)realloc(str,10*sizeof(char));通过使用这行代码，之前具有6个 char 型存储空间的动态数组，其容量扩大为可存储 10 个 char 型数据。
代码示例：将“hello”和“world”两个字符串和为一个字符串。
#include
#include
#include
int main()
{
char*a1=NULL;
char*a2=NULL;
a1=(char*)malloc(10*sizeof(char));
a2=(char*)malloc(10*sizeof(char));
strcpy(a1,"hello ");//将"hello "赋值给a1
strcpy(a2,"world");//将"world"赋值给a2
//获取字符串的长度
int len1=strlen(a1);
int len2=strlen(a2);
//合并两个字符串
if(len1 输出结果：
3、块链存储结构
串的块链存储，指的是使用链表结构存储字符串。
本节实现串的块链存储使用的是无头节点的单链表。当然根据实际需要，你也可以自行决定所用链表的结构（双向链表还是单链表，有无头节点）。
我们知道，单链表中的 "单" 强调的仅仅是链表各个节点只能有一个指针，并没有限制数据域中存储数据的具体个数。因此在设计链表节点的结构时，可以令各节点存储多个数据。
例如，图 1 所示是用链表存储字符串 shujujiegou，该链表各个节点中可存储 1 个字符：
图 1 各节点仅存储 1 个数据元素的链表
同样，图 2 设置的链表各节点可存储 4 个字符：
图 2 各节点可存储 4 个数据元素的链表
从图 2 可以看到，使用链表存储字符串，其最后一个节点的数据域不一定会被字符串全部占满，对于这种情况，通常会用 '#' 或其他特殊字符（能与字符串区分开就行）将最后一个节点填满。
链表各节点存储数据个数的多少可参考以下几个因素：
- 串的长度和存储空间的大小：若串包含数据量很大，且链表申请的存储空间有限，此时应尽可能的让各节点存储更多的数据，提高空间的利用率（每多一个节点，就要多申请一个指针域的空间）；反之，如果串不是特别长，或者存储空间足够，就需要再结合其他因素综合考虑；
- 程序实现的功能：如果实际场景中需要对存储的串做大量的插入或删除操作，则应尽可能减少各节点存储数据的数量；反之，就需要再结合其他因素。
代码示例：
#include
#include
#include
#define linkNum 3//全局设置链表中节点存储数据的个数
typedef struct Link{
char a[linkNum]; //数据域可存放 linkNum 个数据
struct Link * next; //代表指针域，指向直接后继元素
}link; // nk为节点名，每个节点都是一个 link 结构体
link*initLink(link*head,char*str);
void displayLink(link*head);
int main()
{
link * head = NULL;
head = initLink(head, "data.biancheng.net");
displayLink(head);
return 0;
}
//初始化链表，其中head为头指针，str为存储的字符串
link * initLink(link * head, char * str) {
int length = strlen(str);
//根据字符串的长度，计算出链表中使用节点的个数
int num = length/linkNum;
if (length%linkNum) {
num++;
}
//创建并初始化首元节点
head = (link*)malloc(sizeof(link));
head->next = NULL;
link *temp = head;
//初始化链表
for (int i = 0; ia[j] = str[i*linkNum + j];
}
else
temp->a[j] = '#';
}
if (i*linkNum + j < length)
{
link * newlink = (link*)malloc(sizeof(link));
newlink->next = NULL;
temp->next = newlink;
temp = newlink;
}
}
return head;
}
//输出链表
void displayLink(link * head) {
link * temp = head;
while (temp) {
for (int i = 0; i < linkNum; i++) {
printf("%c", temp->a[i]);
}
temp = temp->next;
}
} 输出结果：
三、两种常见算法
1、BF算法
串的模式匹配算法，通俗地理解，是一种用来判断两个串之间是否具有"主串与子串"关系的算法。
主串与子串：如果串 A（如 "shujujiegou"）中包含有串 B（如 "ju"），则称串 A 为主串，串 B 为子串。主串与子串之间的关系可简单理解为一个串 "包含" 另一个串的关系。
实现串的模式匹配的算法主要有以下两种：
- 普通的模式匹配算法；
- 快速模式匹配算法；
BF算法就是其中的一种——普通的模式匹配
普通模式匹配算法，其实现过程没有任何技巧，就是简单粗暴地拿一个串同另一个串中的字符一一比对，得到最终结果。
例如，使用普通模式匹配算法判断串 A（"abcac"）是否为串 B（"ababcabacabab"）子串的判断过程如下：
（1）首先，将串 A 与串 B 的首字符对齐，然后逐个判断相对的字符是否相等
（2）由于串 A 与串 B 的第 3 个字符匹配失败，因此需要将串 A 后移一个字符的位置，继续同串 B 匹配
（3）两串匹配失败，串 A 继续向后移动一个字符的位置，
（4）两串的模式匹配失败，串 A 继续移动，一直移动至下图的位置才匹配成功：
由此，串 A 与串 B 以供经历了 6 次匹配的过程才成功，通过整个模式匹配的过程，证明了串 A 是串 B 的子串（串 B 是串 A 的主串）。
BF 算法的实现思想是：将用户指定的两个串 A 和串 B，使用串的定长顺序存储结构存储起来，然后循环实现两个串的模式匹配过程，C 语言实现代码如下：
代码实现：
#include
#include
int mate(char *B,char *A){//假设B是伪主串，A是伪子串
int i=0,j=0;
while(i 该算法最理想的时间复杂度
O(n)，n 表示串 A 的长度，即第一次匹配就成功。
BF 算法最坏情况的时间复杂度为O(n*m)，n 为串 A 的长度，m 为串 B 的长度。例如，串 B 为 "0000000001"，而串 A 为 "01"，这种情况下，两个串每次匹配，都必须匹配至串 A 的最末尾才能判断匹配失败，因此运行了 n*m 次。
2、KMP算法
快速模式匹配算法，简称 KMP 算法，是在 BF 算法基础上改进得到的算法。KMP 算法不同，它的实现过程接近人为进行模式匹配的过程。例如，对主串 A（"ABCABCE"）和模式串 B（"ABCE"）进行模式匹配，如果人为去判断，仅需匹配两次。
示例：
第一次人为匹配：
第二次人为匹配：
至此，匹配成功。若使用 BF 算法，则此模式匹配过程需要进行 4 次。
由此可以看出，每次匹配失败后模式串移动的距离不一定是 1，某些情况下一次可移动多个位置，这就是 KMP 模式匹配算法。
假设主串 A 为 "ababcabcacbab"，模式串 B 为 "abcac"，则 KMP 算法执行过程为：
第一次匹配：
第二次匹配：
第三次匹配:
使用 KMP 算法只需匹配 3 次，而同样的问题使用 BF 算法则需匹配 6 次才能完成。
KMP 算法的完整 C 语言实现代码为：
#include
#include
//调用了普通求 next 的方式，这里并未直接对 next[1] 赋值为 1，但通过函数第一次运行，也可以得出它的值为 1
void Next(char*T,int *next){
int i=1;
next[1]=0;
int j=0;
while (istrlen(T)) {//如果条件为真，说明匹配成功
return i-(int)strlen(T);
}
return -1;
}
int main() {
int i=KMP("ababcabcacbab","abcac");
printf("%d",i);
return 0;
} 输出结果：
原文链接：
KMP算法（快速模式匹配算法）C语言详解 (biancheng.net)