数据结构-串

4.1串的定义和实现

4.1.2 串的定义

• 串：即字符串（String）是由零个或多个字符组成的有限序列。 例：T=‘iPhone 11 Pro Max?’
• 子串：串中任意个连续的字符组成的子序列。
• 主串：包含子串的串。
• 字符在主串中的位置：字符在串中的序号。
• 子串在主串中的位置：子串的第一个字符在主串中的位置
• 注意：串的位序是从1开始而不是从0开始
• 空串：M=‘’ M是空串，里面没有存任何东西
• 空格串：N=‘ ’ N是由三个空格字符组成的空格串，每个空格字符占1B
• 串是一种特殊的线性表，数据元素之间呈线性关系

串的数据对象限定为字符集（如中文字符、英文字符、数字字符、标点字符等）

4.1.3 串的基本操作

StrAssign(&T,chars)：赋值操作。把串T赋值为chars。 StrCopy(&T,S)：复制操作。由串S复制得到串T。 StrEmpty(S)：判空操作。若S为空串，则返回TRUE，否则返回FALSE。 StrLength(S)：求串长。返回串S的元素个数。 ClearString(&S)：清空操作。将S清为空串。 DestroyString(&S)：销毁串。将串S销毁（回收存储空间）。 Concat(&T,S1,S2)：串联接。用T返回由S1和S2联接而成的新串 SubString(&Sub,S,pos,len)：求子串。用Sub返回串S的第pos个字符起长度为len的子串。 Index(S,T)：定位操作。若主串S中存在与串T值相同的子串，则返回它在主串S中第一次出现的 位置；否则函数值为0。 StrCompare(S,T)：比较操作。若S>T，则返回值>0；若S=T，则返回值=0；若S<T，则返回值<0

4.2 串的存储结构

4.2.1 串的顺序存储

串的顺序存储（静态数组）：

// ch[0]废弃不用，声明int型变量length来存放串的长度
#define MAXLEN 255    //预定义最大串长为255
 
typedef struct{        
    char ch[MAXLEN];  //每个分量存储一个字符 静态数组实现(定长顺序存储)
    int length;       //串的实际长度
}SString;
 
// 串的初始化
bool InitString(SString &S){
    S.length = 0;    
    return true;
}
 
// 求串的长度
int StrLength(SString S){    
    return S.length;
}
 
// 求子串
bool SubString(SString &Sub, SString S, int pos, int len){ 
    if(pos+len-1 > S.length)            //子串范围越界
        return false;    
    for(int i=pos; i<pos+len; i++)
        Sub.ch[i-pos+1] = S.ch[i];
    Sub.length = len;
    return true;
}
 
// 比较操作。笔记S、T的大小，若S>T，则返回值大于0；若S=T，则返回值等于0；若S<T，则返回值小于0
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;
}
 
//定位操作。主串S中存在与串T值相同的子串则返回串T在主串S中第一次出现的位置，若无法定位则返回0
int Index(SString S, SString T){    
    int i=1, n=StrLength(S), m=StrLength(T);    //n求出S的长度，m表示T的长度
    SString sub;   //用于暂存子串
    while(i<=n-m+1){       //从头到尾依次取     
        SubString(sub, S, i, m);        
        if(StrCompare(sub, T)!=0)            
            ++i;        
        else            
            return i;    //返回子串在主串中的位置
    }
    return 0;	//S中不存在与T相等的子串
}
 
void test{    
    SString S;    
    InitString(S);    
    ...
}

串的顺序存储（动态数组）：

#define MAXLEN 255
 
typedef struct{  
    char *ch;        //按串长分配存储区，ch指向串的基地址
    int length;
}HString;            //动态数组实现(堆分配存储)
 
bool InitString(HString &S){ 
    S.ch = (char *)malloc(MAXLEN * sizeof(char)); //malloc分配一片连续的存储空间
    if(S.ch == NULL)      
        return false;  
    S.length = 0;  
    return true;
}
 
void test{  
    HString S;  
    InitString(S);  
    ...
}

4.2.2 串的链式存储

typedef struct StringNode{   
    char ch;	//每个结点存1个字符  
    struct StringNode *next;
}StringNode, *String;

上述方式存储密度低， 一般采用下面的方式，使每个结点存储多个字符

typedef struct StringNode{   
    char ch[4];		//每个结点存多个字符   
    struct StringNode *next;
}StringNode, *String;

4.3 串的模式匹配

4.3.1_朴素模式匹配算法

• 字符串模式匹配：在主串中找到与模式串相同的⼦串，并返回其所在位置

• 主串⻓度为n，模式串⻓度为 m 朴素模式匹配算法：将主串中所有⻓度为m的⼦串依次与模式串对⽐，直到找到⼀个完全匹配的⼦串， 或所有的⼦串都不匹配为⽌。 最多对⽐ n-m+1 个⼦串

• Index(S,T)：定位操作。若主串S中存在与串T值相同的⼦串，则返回它在主串S中第⼀次出现 的位置；否则函数值为0

• 接下来不使用字符串的基本操作，直接通过数组下标实现朴素模式匹配算法

// 在主串S中找到与模式串T相同的子串并返回其位序，否则返回0
int Index(SString S, SString T){   
    int i=1, j=1;  
    while(i<=S.length && j<=T.length){    
        if(S.ch[i] == T.ch[j]){     //如果i里面存的字符和j里面存的相同的话
            ++i; ++j;     //++继续比较后继字符
        }else{        
            i=i-j+2;      //i指针指向下一个子串的起始位置
            j=1;          //j指针后退回到第一个位置重新开始匹配 
        }   
    }   
    if(j>T.length) 
        return i-T.length;   
    else       
        return 0;
}

设主串⻓度为 n，模式串⻓度为 m，则 最坏时间复杂度 = O(nm)

最坏的情况，每个⼦串都要对⽐ m 个字符，共 n-m+1 个⼦串，复杂度 = O((n-m+1)m) = O(nm)

4.3.2_1_KMP算法

朴素模式匹配算法的缺点
⼀旦发现当前这个⼦串中某个字符不匹配，就只能转⽽匹配下⼀个⼦串（从头开始）

next数组只和短短的模式串 有关，和长长的主串⽆关

KMP算法：当子串和模式串不匹配时，主串指针 i 不回溯，模式串指针 j=next[j]。

KMP算法最坏时间复杂度 O(m+n)

其中，求 next 数组时间复杂度 O(m)

模式匹配过程最坏时间复杂度 O(n)

KMP算法的代码实现

// 获取模式串T的next[]数组
void getNext(SString T, int next[]){ 
    int i=1, j=0;  
    next[1]=0;  
    while(i<T.length){   
        if(j==0 || T.ch[1]==T.ch[j]){ 
            ++i; ++j;      
            next[i]=j;  
        }else      
            j=next[j]; 
    }
}
 
// KPM算法，求主串S中模式串T的位序，没有则返回0
int Index_KMP(SString S, SString T){   
    int i=1, j=1;  
    int next[T.length+1]; 
    getNext(T, next);  
    while(i<=S.length && j<=T.length){  
        if(j==0 || S.ch[i]==T.ch[j]){   //如果主串的元素和模式串的元素相等或j等于0时
            ++i;  
            ++j;               //i和j++，继续比较后继字符
        }else   
            j=next[j];         //模式串向后移动
    }    
    if(j>T.length)   
        return i-T.length;      //j大于模式串长度说明匹配成功
    else
        return 0;
}
 
int main() {
	SString S={"ababcabcd", 9};
	SString T={"bcd", 3};
	printf("%d ", Index_KPM(S, T));	//输出9
}

KMP算法精髓：利用已经匹配过的模式串的信息，求出next数组→利用next数组进行匹配(主串指针不回溯）

4.2.2_2_求next数组

next数组的作⽤：当模式串的第 j 个字符失配时，从模式串的第 next[j] 的继续往后匹配

• 任何模式串第⼀个字符不匹配时，只能匹配下⼀个⼦串，因此，next[1]都⽆脑写 0 第2个字符不匹配时，应尝试匹配模式串的第1个字符， 因此，next[2]都⽆脑写 1 接下来的字符，在不匹配的位置前划一根分界线，模式串一步一步往后退，直到分界线前的“对的上”，或模式串完全越过分界线位置,如下面为第3个字符不匹配的情况

4.2.3_KMP算法的进一步优化

第3个字符和第1个字符相同，所以 可以直接跳到next[1]指向的位置，第5个字符跟第2个字符相同，直接跳到next[2]指向的位置

void getNextval(SString T, int nextval[]){
    int i=1,j=0;
    nextval[1]=0;
    while(i<T.length){
        if(j==0 || T.ch[i]==T.ch[j]){
            ++i; ++j;
            if(T.ch[i]!=T.ch[j])
                nextval[i]=j;
            else
                nextval[i]=nextval[j];
        }else
            j=nextval[j];
    }
}