串的定长顺序存储
定义
#define MAXSSIZE 100
char s
[MAXSSIZE
];
模式匹配
设s和t是给定的两个串，在主串s中找到与串t相等的子串的位置的过程称为模式匹配，串t被称为模式。如果在s中找到等于t的子串，则称匹配成功，模式匹配函数将返回t在s中的第一次出现的存储位置(或序号)，否则匹配失败，返回0。
1. 简单的模式匹配算法 （BF）
最好情况：
∑
i
=
1
n
−
m
+
1
p
i
×
(
i
−
1
+
m
)
=
∑
i
=
1
n
−
m
+
1
1
n
−
m
+
1
×
(
i
−
1
+
m
)
=
n
+
m
2
\sum_{i=1}^{n-m+1} p_i\times( i - 1+m) = \sum_{i=1}^{n-m+1} \frac{1}{n-m+1}\times( i - 1+m) = \frac{n+m}{2}
∑i=1n−m+1pi×(i−1+m)=∑i=1n−m+1n−m+11×(i−1+m)=2n+m 时间复杂度：O(n+m)最坏情况：
∑
i
=
1
n
−
m
+
1
\sum_{i=1}^{n-m+1}
∑i=1n−m+1
p
i
×
(
i
×
m
)
p_i \times( i\times m)
pi×(i×m)
=
=
=
∑
i
=
1
n
−
m
+
1
\sum_{i=1}^{n-m+1}
∑i=1n−m+1
1
n
−
m
+
1
\frac{1}{n-m+1}
n−m+11
×
(
i
×
m
)
\times( i\times m)
×(i×m) =
m
×
(
n
−
m
+
2
)
2
\frac{m\times (n-m+2)}{2}
2m×(n−m+2) 时间复杂度：O(n*m)
2. 改进后的模式匹配算法（KMP）
尽量利用已经部分匹配的结果信息来进行后面的匹配工作，尽量让主串s指针i不要回溯，而只回溯模式串t的指针来进行模式匹配，这样做就省去了主串指针回溯进行比较的时间。
串的堆存储结构
在C语言中 ，提供了一个称之为“堆”的共享空间，可以在程序运行过程中，由系统利用函数malloc( ) 和 free( ) 来动态地申请或释放一块连续空间。 串的堆式存储结构仍属于串的 顺序存储结构 范畴，但与前面的定长顺序存储方式存在的区别在于其存储空间是在程序执行过程中 动态分配 的，而不是静态分配的。
定义
typedef struct{
char *ch
;
int length
;
}Hstring
;
基本运算
1. 串赋值
status
strassign(Hstring t
, char *chars
){
if(t
.ch
) free(t
.ch
);
for(i
= 0, c
= chars
; c
; ++i
, ++c
);
if(!i
){
t
.ch
= null
;
t
.length
= 0;
}
else{
if(!(t
.ch
= (char *)malloc(i
*sizeof(char)))) exit(overflow
);
t
.ch
[0..i
-1] = chars
[0..i
-1];
t
.length
= i
;
}
}
2. 串复制
void StrCopy(Hstring
*s1
,Hstring s2
){
if(s1
.ch
) free(s1
.ch
);
if(!s2
.length
){
s1
.ch
= null
;
s1
.length
= 0;
}
else{
if(!(s1
.ch
= (char *)malloc(s2
.length
* sizeof(char))) exit(overflow
);
s1
.ch
[0.. s2
.length
-1] = s2
.ch
[0.. s2
.length
-1];
s1
.length
= s2
.length
;
}
}
3. 串连接
status
concat(Hstring s
, Hstring s1
, Hstring s2
){
if(s
.ch
) free(s
.ch
);
if(!(s
.ch
) = (char*)malloc((s1
.length
+ s2
.length
)*sizeof(char))) exit(overflow
);
s
.ch
[0..s1
.length
-1] = s1
.ch
[0..s1
.length
-1];
s
.length
= s1
.length
+ s2
.length
;
s
.ch
[s1
.length
..s
.length
-1] = s2
.ch
[0..s2
.length
-1];
}
串的链式存储结构
定义
typedef struct node
{
char data
;
struct node
*next
;
}Lstring
;
Lstring
*str
;
存储密度 = 串值所占存储位 / 实际分配存储位 优点：便于进行插入和删除运算，只需修改相关指针。 缺点：存储空间利用率太低，因为每一个字符构成一个结点时都需要一个指针域，导致这种结构下的存储密度偏低。 解决方案：一个结点里不只存放一个字符，而是存放多个字符，此时形成了串的块链结构。
串的块链结构
#define nodesize 80
typedef struct node
{
char data
[nodesize
];
struct node
*next
;
}Lstring
;
链表中的最后一个结点不一定全被串值占满，为了表示该串已结束，通常会在该结点未被占满处补上“#”或其它的非串值字符。对于块链而言，在做插入、删除字符的操作时，可能会引起结点之间字符的移动，算法实现起来比较复杂。
