数据结构学习笔记（4串）

最新推荐文章于 2023-10-10 00:08:01 发布

sx失去理智

最新推荐文章于 2023-10-10 00:08:01 发布

阅读量533

点赞数 1

文章标签：数据结构排序算法算法

本文链接：https://blog.csdn.net/sxH3O/article/details/122580917

版权

串

1.定义

字符串，即是由零个或多个字符组成的有限序列，一般记为S='a1a2…an'(n>=0)。

其中，S是串名，单引号括起来的字符序列是串的值，ai可以是字母、数字或其他字符；串中字符的个数n称为串的长度，n=0时的串称为空串。

例：S="HelloWorld!"(Java、C为双引号) T='iPhone 11 pro max?'(Python为单引号)

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

字符在主串中的位置：字符在串中的序号。

2.基本操作

比较操作StrCompare(S,T)：若S>T,则返回值大于0；等于则返回值等于0，小于则返回值小于0。

从第一个字符开始往后依次对比，先出现更大字符的串就更大；

长串的前缀与短串相同时，长串更大。

//比较操作。若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;
}

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rBJFwa3P-1642574819742)(数据结构学习笔记.assets/image-20220118173205182.png)]

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相等的子串
}

3.串的存储结构

（1）顺序存储

静态数组实现：

#define MAXLEN 255		//预定义最大串长为255
typedef struct
{
    char ch[MAXLEN];	//每个分量存储一个字符,ch[0]默认不用，优点是字符的位序和数组下标相同
    int length;			//串的实际长度
}

动态数组实现：（堆分配存储）

typedef struct
{
    char *ch;
    int length;
}HString;
HString S;
S.ch=(char *)malloc(MAXLEN*sizeof(char));	//用完需要手动free
S.length=0;

（2）链式存储

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5PZMoCfp-1642574819742)(数据结构学习笔记.assets/image-20220118000011643.png)]

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

该存储结构存储密度低，每个字符1B，每个指针4B。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X08r3Umo-1642574819743)(数据结构学习笔记.assets/image-20220118000117770.png)]

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

该存储结构存储密度提高。

4.字符串模式匹配

（1）朴素模式匹配算法

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

朴素模式匹配算法：将主串中所有长度为m的子串依次与模式串对比，直到找到一个完全匹配的子串，或所有的子串都不匹配为止。（最多对比n-m+1个子串）（Index定位操作即朴素模式匹配算法）

通过数组下标实现朴素模式匹配算法：

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=i-j+2;	//指向下一个子串的起始位置
            j=1;		//指针后退重新开始匹配
        }
        if(j>T.length)
            return i-T.length;
        else 
            return 0;
    }
}

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

最坏时间复杂度：每次均为匹配到模式串最后一个字母时发现匹配失败。

在最坏的情况中，每个子串都要对比m个字符，共n-m+1个子串，复杂度=O((n-m+1)m)=O(nm)。（注：很多时候，n远大于m）

在最好的情况中，每个子串的第一个字符就匹配失败，共n-m+1个子串，复杂度=O(n-m+1)=O(n)。

（2）KMP算法

算法分析

算法精髓：利用好已经匹配过的模式串的信息。

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[i])
        {
            i++;j++;		//继续比较后继字符
        }
        else
            j=next[j];		//模式串向右移动,i保持不变
        if(j>T.length)
            return i-T.length;
        else
            return 0;
    }
}

KMP算法的最坏时间复杂度为O(m+n)，其中，求next数组时间复杂度O(m)，模式匹配过程最坏时间复杂度O(n)。

求next数组

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

next[1]、next[2]在任何情况下均分别为0、1。对于其他的next，在不匹配的位置前，划一条分界线。模式串一步一步往后退，直到分界线之前“能对上”，或模式串完全跨过分界线为止。此时j指向哪，next数组值就是多少。

另一种方法是，当此集合不空，且j不等于1时，next[j]即第j个元素前j-1个元素首尾重合部分个数再加一。

//通过计算返回子串T的next数组
void get_next(SString T,int *next)
{
    int i,k;
    i=1,k=0;
    next[1]=0;
    while(i<T[0])
    {
        if(k==0||T[i]==T[k])
        {
            i++;
            k++;
            next[i]=k;
        }
        else
            k=next[k];		//r
    }
}

m个字符，共n-m+1个子串，复杂度=O((n-m+1)m)=O(nm)。（注：很多时候，n远大于m）