数据结构——串

最新推荐文章于 2023-10-11 15:40:11 发布

gxyqn626

最新推荐文章于 2023-10-11 15:40:11 发布

阅读量434

点赞数

分类专栏： C语言 MarkDown

本文链接：https://blog.csdn.net/gxyqn626/article/details/81461605

版权

MarkDown 同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

C语言

5 篇文章 0 订阅

订阅专栏

串的定义

串:由零个/多个字符组成的有限序列，又叫字符串
记法：s=”a1a2a3a4a5’—an”
ai(i大于等于1 小于等于n）
n：字符串的长度
空串：”’
空格串：只包含空格的串，有内容，有长度、
子串：任意个数的连续字符组成的子序列
主串：包含字串的串
子串在主串中的位置：子串的第一个字符在主串中的序号

串的比较

通过ASCII码值来比较

相等

1、长度相等
2、各个对应位置的字符都相等

不相等

1、 s=”lose” t=”loser”
前四位都相同，t字符串多了一位，所以s<t
2、s=”happen” y=”happy”
两个串的前四位都相同
第五位’e’的ASCII码小于’y’的ASCII码
所以s<t

串的抽象数据类型

StrAssign(T,*chars)//生成一个值等于字符串常量chars的串T
StrCopy(T,S)//把串S复制给串T
ClearString(S)//将串S清空
StringEmpty(S)//判断串S是否为空,为空，返回true,否则返回false
StrLength(S)//返回串S的元素个数，即串的长度
StrCompare(S,T)//若S>T，返回>0|若S=T，返回0|若S<T，返回<0
Concat(T,S1,S2)//用T返回由S1和S2连接的新串
SubString(Sub,S,pos,len)//用Sub返回串S的第pos个字符起长度为len的子串
//前提：1小于等于pos小于等于StrLength(S)
//0小于等于len小于等于StrLength(S)-pos+1
Index(S,T,pos)//如果主串S中包含串T，返回它在主串中第pos个字符后第一次出现的位置，否则返回0
Replace(S,T,V)//用V替换主串S中出现的所有与T相等的不重叠的子串
StrInsert(S,pos,T)//在S的第pos个字符前插入串T(1小于等于pos小于等于StrLength(S)+1

StrDelete(S,pos,len)//从串中删除第pos个字符起长度为len的子串（1小于等于pos小于等于StrLength(S)-len+1)

串的存储结构

串的顺序存储结构（数组)

用定长数组来定义，弊端:存储空间不够，时常会出现字符串截断的现象。

串的链式存储结构（链表）

结构体中的每个元素数据是一个字符或多个字符。

算法一：暴力匹配算法

模式匹配:子串在主串中的位置
对主串做大循环，每个字符开头做T的长度的小循环，直到匹配成功或遍历结束。

int Index(String S,String T,int pos)
    {
        int i=pos;
        int j=1;
        while(i<=S[0]&&j<=T[0])//S[0]和T[0]是最大长度
        {
            if(s[i]==s[j])
            {
                ++i;
                ++j;
            }
            else
            {
                i=i-j+2;//i退回到上一次开始的后一位
                j=1;//j退回到下标1 重新开始匹配
            }
        }
        if(j>T[0])//T已经匹配完毕
        {
            return i-T[0];//返回在主串中的位置
        }
        else
        {

            return 0;
        }
    }

也可以使下标从0开始

    int index(char *S,char *T)
    {

        int SL=strlen(S);
        int TL=strlen(T);
        int i=0;
        int j=0;
        while(i<SL&&j<TL)
        {
            if(S[i]==T[j])
            {
                ++i;
                ++j;
            }
            else
            {
                i=i-j+1;
                j=0;
            }
        }
        if(j==TL)
        {
            return i-j;
        }
        else
        {
            return 0;
        }
    }
    #include<stdio.h>
    #include<string.h>
    int main()
    {
        char a[10];
        char b[5];
        int c;
        c=index("abcdefacdefb","cdefb");
        printf("子串在主串中的位置为%d",c);
    }

不足之处：暴力匹配算法的效率过低，时间复杂度高。

算法二—KMP模式匹配算法

假设现在主串匹配到i位置，子串匹配到j位置
*如果j=-1或当前字符匹配成功(s[i]==p[j]) 那么i++ j++继续匹配下一个字符
如果j!=-1且当前字符匹配失败(s[i]!=p[j]），那么令i不变，j=next[j]*。即匹配失败时，子串p相对于主串s向右移动了j-next[j]位。模式串向右移动的位数为：失配字符所在位置 - 失配字符对应的next 值。
next数组各值的含义:当前字符之前的字符串中，由多大长度的相同前缀后缀。
next[j]=k 代表j之前的字符串有最大长度为k的相同前缀后缀。
即在某个字符失配时，该字符对应的next值会告诉你下一步匹配中，子串应该跳到哪个位置。
如果next[j]等于-1或0，那么跳到子串的开头
如果next[j]=k&&k>0,则代表下次匹配跳到j之前的某个字符。
如图所示
这里写图片描述
这里子串的D与主串的空格不相匹配
所以i不变，j=next[j]=2,即子串向右移动了(6-2=4位）

此时已经向右移动了4位,s[10]和p[2]继续匹配

前提：求得next[]数组

#失配时，模式串向右移动的位数为：失配字符所在位置 - 失配字符对应的next 值

方法一：求当前字符之前的字符串的最大相同前后缀（直接求）

a b a b
-1 0 0 1

方法二:先求出最大长度表，然后右移一位，初始值赋为-1

最大长度表
A B C D A B D—-子串
0 0 0 0 1 2 0——最大长度值
-1 0 0 0 0 1 2 0—–next[]数组
这里写图片描述

方法三:通过代码来递推

已知next[0,1,2“`j],怎样求next[j+1]?
(1)对于P的前j+1个序列字符，若p[k] == p[j]，则next[j + 1 ] = next [j] + 1 = k + 1。
如图所示
这里写图片描述
这里已知next[j]=k=2,又因为p[k]==p[j](说明E之前的字符串的前缀和后缀相同），所以next[j+1]=next[j]+1=k+1=3
说白了，就是在C之前的字符串中，我们早就知道ABCDAB这个字符串的前缀和后缀是AB，在这里，我们又知道了E之前的字符串ABCDABC中的C相等。这里的C分别是前一个的Pk和Pj。
（2）如果说pk!=pj,用p[next[k]] 去跟pj 继续匹配，如果p[ next[k] ]跟pj还是不匹配，则需要寻找长度更短的相同前缀后缀，即下一步用p[ next[ next[k] ] ]去跟pj匹配。此过程相当于模式串的自我匹配，所以不断的递归k = next[k]，直到要么找到长度更短的相同前缀后缀，要么没有长度更短的相同前缀后缀。

利用递归求next数组
void GetNext(char *p,int next[])
{
    int pLen=strlen(p);
    next[0]=-1;
    int k=-1;
    int j=0;
    while(j<pLen-1)
    {
        if(k==-1||p[k]==p[j])//前缀等于后缀
        {
            ++k;
            ++j;
            next[j]=k;
        }
        else
        {
            k=next[k];
        }
    }
}

根据next数组进行匹配

如图所示
这里写图片描述

int KmpSearch(char* s, char* p)
{
    int i = 0;
    int j = 0;
    int sLen = strlen(s);
    int pLen = strlen(p);
    while (i < sLen && j < pLen)
    {
        //①如果j = -1，或者当前字符匹配成功（即S[i] == P[j]），都令i++，j++    
        if (j == -1 || s[i] == p[j])
        {
            i++;
            j++;
        }
        else
        {
            //②如果j != -1，且当前字符匹配失败（即S[i] != P[j]），则令 i 不变，j = next[j]    
            //next[j]即为j所对应的next值      
            j = next[j];
        }
    }
    if (j == pLen)
        return i - j;
    else
        return -1;
}