数据结构 - 串
6、串
串的定义
串，即字符串（string）是由零个或多个字符串组成的有限序列。
术语：
- 子串：串的任意个连续的字符组成的子序列
- 主串：包括子串的串
- 字符在主串中的位置：字符在串中的序号
- 子串在主串中的位置：子串的第一个字符在主串中的位置
注意：这里的位置是从1开始，而不是0
6.1、串的顺序存储
串的静态存储
#define MaxSize 255
typedef struct {
char ch[MaxSize];//静态的字符数组
int length;//字符串的长度
}SString;
串的动态存储
typedef struct {
char * ch;//字符的起始地址
int length;//字符串的长度
}HString;
//初始化
int InitHString(HString * s){
&s.ch = (char *)malloc(sizeof(char)*MaxSize);
&s.length = 0;
return 1;
}
6.2、串的链式存储
一个串值存储一个字符
typedef struct StringNode{
char ch;//1个字节
struct StringNode *next;//四个字节
}StringNode,*String;
缺点：存储密度低，字符1B，next指针4B；
一个串值存储多个个字符
typedef struct StringNode{
char ch[4];//4个字节
struct StringNode *next;//四个字节
}StringNode,*String;
测试
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 255
#define true 1
#define false 0
#define boolean int
typedef struct SString{
char ch[MaxSize];//字符串
int length;//字符串的长度
}SString;
//把ch赋值给S的字符串
boolean StrAssign(SString *S,char ch[]){
S->ch[0] = ' ';
for(int i = 1;i <= S->length;i++){
S->ch[i] = ch[i-1];
}
return true;
}
//字符串判断是否为空
boolean StrEmpty(SString S){
if(S.length == 0) return true;
else return false;
}
//清空字符串
boolean ClearString(SString *S){
if(!StrEmpty(*S)){
*S->ch = "";
S->length = 0;
}
return true;
}
//求字符串长度
int StrLength(SString S){
return S.length;
}
//复制操作
boolean StrCopy(SString *T,SString S){
T->ch[0] = ' ';
if(!StrEmpty(S)){
for(int i=1;i<=S.length;i++){
T->ch[i] = S.ch[i];
}
T->length = S.length;
}
return true;
}
//串连接；用T返回S1 和 S2连接的新串 时间复杂度O(max(S1.length,S2.lengtt))
boolean Concat(SString *T,SString S1,SString S2){
T->ch[0] = ' ';
if(S1.length+S2.length > MaxSize) return false;//长度超出边界
int length = S1.length>S2.length?S1.length:S2.length;//选择字符串大的那个长度
if(!StrEmpty(S1) || !StrEmpty(S2)){
for(int i=1;i<=length;i++){//循环赋值
if(i<=S1.length){
T->ch[i] = S1.ch[i];//赋值S1
}
if(i+S1.length <= S2.length + S1.length){
T->ch[i+S1.length] = S2.ch[i];//赋值S2
}
}
T->length = S1.length + S2.length;//长度赋值为S1+S1的长度
}
return true;
}
//求子串
boolean SubString(SString *Sub,SString S,int pos,int len){
if(pos + len - 1 > S.length || pos < 1) return false;//越界了
Sub->ch[0] = ' ';
for(int i=pos;i<len+pos;i++){
Sub->ch[i-pos+1] = S.ch[i]; //子串赋值
}
Sub->length = len; //子串的长度
return true;
}
//比较操作 返回大于0：表示S>T;等于0，S=T；返回小于0，S<T
int StrCompare(SString S,SString T){
for(int i = 1;i <= S.length && i <= T.length;i++){
if(S.ch[i] != T.ch[i]){
return S.ch[i] - T.ch[i];
}
}
return S.length - T.length;
}
//定位操作，返回串T，在S中第一次出现的位置
int Index(SString S,SString T){
int i = 1,n = StrLength(S),m = StrLength(T);//记录两个串的大小
SString Sub;
while(i <= n - m + 1){//依次寻找子串比对
SubString(&Sub,S,i,m);
if(StrCompare(Sub,T) == 0){
return i;//比对成功就返回位置
}else{
i++;//失败就++
}
}
return 0;//全部寻找完，都没有匹配的，就返回0
}
//定位操作（朴素模式的匹配算法）
int Index2(SString S,SString T){
int k = 1;
int i = k,j=1;
while(i <= S.length && j <= T.length){
if(S.ch[i] == T.ch[j]){
j++;
i++;
}else{
j = 1;
i = ++k;
}
}
if(j > T.length) return k;
else return 0;
}
//模式字符串的next数组
void get_next(SString T,int next[]){
int i=1,j=0;
next[1] = 0;
while(i < T.length){
if(j == 0 || T.ch[i] == T.ch[j]){
++i;++j;
next[i] = j;
}else{
j = next[j];
}
}
}
//KPM算法
int KPM_Index(SString S,SString T){
int i = 1,j=1;
int *next = (int *)malloc(sizeof(int)*(T.length+1));
get_next(T,next);
while(i <= S.length && j <= T.length){
if(j==0 || S.ch[i] == T.ch[j]){
j++;
i++;
}else{
j = next[j];
}
}
if(j > T.length) return i-T.length;
else return 0;
}
int main(){
SString S;
char ch[] = "abcdefghijklnm";
S.length = 14;
StrAssign(&S,ch);
printf("字符串： %s \n",S.ch);
printf("字符串长度：%d \n",StrLength(S));
printf("字符串是否为空：%d \n",StrEmpty(S));
SString T;
StrCopy(&T,S);
printf("字符串T： %s \n",T.ch);
printf("字符串长度： %d \n",T.length);
printf("字符串T是否为空：%d \n",StrEmpty(T));
SString S1;
char ch1[] = "abcdefghijklnm";
S1.length = 14;
StrAssign(&S1,ch1);
SString S2;
char ch2[] = "rrrrr";
S2.length = 5;
StrAssign(&S2,ch2);
SString T1;
Concat(&T1,S1,S2);
printf("字符串T1： %s \n",T1.ch);
printf("字符串T1长度： %d \n",T1.length);
printf("字符串T1是否为空：%d \n",StrEmpty(T1));
ClearString(&S);
printf("字符串： %s \n",S.ch);
printf("字符串是否为空：%d \n",StrEmpty(S));
//求子串
SString Sub;
SubString(&Sub,T1,5,5);
printf("字符串Sub： %s \n",Sub.ch);
printf("字符串Sub长度： %d \n",Sub.length);
printf("字符串Sub是否为空：%d \n",StrEmpty(Sub));
SString C1;
SString C2;
char str1[] = "abcde";
C1.length = 5;
StrAssign(&C1,str1);
char str2[] = "bcd";
C2.length = 3;
StrAssign(&C2,str2);
printf("C1 > C2 : %d \n",StrCompare(C1,C2));
printf("C2 是 C1的子串吗？是返回位置，不是返回0：%d \n",Index2(C1,C2));
printf("KPM算法 ： C2 是 C1的子串吗？是返回位置，不是返回0：%d \n",KPM_Index(C1,C2));
return 0;
}
//结果：
字符串： abcdefghijklnm
字符串长度：14
字符串是否为空：0
字符串T： abcdefghijklnm
字符串长度： 14
字符串T是否为空：0
字符串T1： abcdefghijklnmrrrrr
字符串T1长度： 19
字符串T1是否为空：0
字符串：
字符串是否为空：1
字符串Sub： efghi
字符串Sub长度： 5
字符串Sub是否为空：0
C1 > C2 : -1
C2 是 C1的子串吗？是返回位置，不是返回0：2
KPM算法 ： C2 是 C1的子串吗？是返回位置，不是返回0：2
朴素模式的匹配算法
将主串中与模式串相同长度的连续子串弄出来，和模式串进行比较，不同就换下一个，相同就返回
最好时间复杂度为：O(n)
最坏时间复杂度为：O(nm)
KPM字符串匹配算法
当子串和模式串不匹配的时候，主串指针i不回溯，模式串指针 j = next[j];
next数组手算方法：当第j个字符匹配失败，由前1~j-1个字符组成的串记为S，则：next[j]=S的最长相等前后缀长度+1；特别的next[1]=0
算法的平均时间复杂度为：O(m+n)
KPM优化算法：当子串和模式串不匹配时，j=nextval[j]
//优化模式字符串的next数组
void get_nextval(SString T,int next[]){
int i=1,j=0;
next[1] = 0;
while(i < T.length){
if(j == 0 || T.ch[i] == T.ch[j]){
++i;++j;
next[i] = j;
}else{
j = next[j];
}
}
for(int j = 2;j<=T.length;j++){
if(T.ch[next[j]] == T.ch[j]){
next[j] = next[next[j]];
}
}
}
