数据结构——第四章《串》-CSDN博客

本文链接：https://blog.csdn.net/WBushYdc/article/details/133661111

第四章串

4.1串的定义和实现

4.1.1串的定义和基本操作

1，定义

串，即字符串（String）是由零个或多个字符组成的有限序列。一般记为S=‘a1a2……an’ (n 20)其中，s是串名，单引号括起来的字符序列是串的值；a；可以是字母、数字或其他字符；串中字符的个数n称为串的长度。n=0时的串称为空串（用（表示）。

子串：串中任意个连续的字符组成的子序列。

主串：包含子串的串。字

符在主串中的位置：字符在串中的序号。(第一次出现的位置，从1开始)

子串在主串中的位置：子串的第一个字符在主串中的位置。

2，串VS线性表

串是一种特殊的线性表，数据元素之间呈线性关系。

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

串的基本操作，如增删改查等通常以子串为操作对象

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,则返回值<O。（从第一个字符开始往后依次对比，先出现更大字符的串就更大）

4，字符集编码

每个字符在计算机中对应一个二进制数，比较字符的大小其实就是比较二进制数的大小。

4.1.2串的存储结构

1，顺序存储

1，静态数组

#define MAXLEN 255
typedef struct{
    char ch[MAXLEN];//每个分量存储一个字符
    int length;//串的实际长度
}SString;

2，动态数组

typedef struct{
    char *ch;//按串长分配存储区，ch指向串的基地址
    int length;//串的长度
}HString;
S.ch = (char *)malloc(MAXLEN * sizeof(char));
S.length = 0;

2，链式存储

typedef struct StringNode{
    char ch;//每个节点存一个字符，存储密度低
    struct StringNode *next;
}StringNode, *String;

typedef struct StringNode{
    char ch[4];//每个节点存多个字符，存储密度提高
    struct StringNode * next;
}StringNode, *String;

3，基本操作实现

定义

#define MAXLEN 255
typedef struct{
    char ch[MAXLEN];//每个分量存储一个字符
    int length;//串的实际长度
}SString;

求子串：bool SubString(SString &Sub,SString S,int pos,int len)

//用Sub返回串s的第pos个字符起长度为len的子串
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;
}

串的比较：int StrCompare(SString S,SString 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;
}

求串在主串中的位置：int Index(SString S,SString T)

//若主串S中存在与串T值相同的子串，则返回它在主串S中第一次出现的位置，否则函数值为0
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)
            ++i;
        else
            return i;//返回子串在主串中的位置
    }
    return 0;//S中不存在与T相等的子串
}

4.2串的模式匹配

4.2.1朴素模式匹配算法（暴力解决）

1，算法思想

主串长度n，模式串长度m

将主串中所有长度为m的子串与模式串对比（n-m+1个子串）

找到第一个与模式串匹配的子串，并返回子串起始位置

若所有子串都不匹配，则返回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++;//继续比较后继字符
        }
        else
        //若当前子串匹配失败，则主串指针i指向下一个子串的第一个位置，模式串指针j回到模式串的第一个位置
        {
            i = i - j + 2;
            j = 1;			//指针回退重新开始匹配
        }
    }
    if(j > T.length)
        return i - T.length;
    else
        return 0;
}

2，最坏时间复杂度

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

4.2.2KMP算法

根据模式串T，求出next数组

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

利用next数组进行匹配（主串指针不回溯）

int Index_KMP(SString S, SString T, int next[])
{
    int i = 1, j = 1;
    while(i <= S.length && j <= T.length)
    {
        if(j == 0 || S.ch[i] == T.ch[j])
        {
            ++i;
            ++j;//继续比较后续字符串
        }
        else
            j = next[j];//模式串向右移动
    }
    if(j > T.length)
        return i - T.length;	//匹配成功
    else
        return 0;
}