串的实现详解和朴素的模式匹配算法

最新推荐文章于 2024-09-12 13:19:42 发布
最新推荐文章于 2024-09-12 13:19:42 发布
阅读量63 收藏
点赞数 1
分类专栏： 数据结构详解 文章标签： 算法 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haijv/article/details/129978373
版权
文章详细介绍了串的顺序存储结构，包括生成、复制、清空、判断空、获取长度、连接、子串、比较、插入、删除和替换等基本操作。此外，还讲解了朴素的模式匹配算法，并提供了一个简单的C语言实现。文章末尾提到了当匹配长度增加时，朴素算法效率低下，暗示后续会介绍更高效的KMP算法。
摘要由CSDN通过智能技术生成

6.1 串的实现详解和朴素的模式匹配算法

文章目录

6.1.1 串的简介

串是由零个或多个字符组成的有序序列，又称字符串。一般记为s=“a1a2a3···an”（n>=0），s是串的名称，串的字符数目n称为串的长度，零个字符的串称为空串。



6.1.2 串的顺序存储结构定义



串的顺序存储结构是用一组地址连续的存储单元来存储串中的字符序列，如下图所示：
在这里插入图片描述

数组下标为0的位置存储串的长度。

代码实现串也十分简单，利用字符数组即可，代码如下：

typedef char String[MAXSIZE+1];     //0号单元存放串的长度




6.1.3 串的各种操作

如下表所示：

操作函数操作结果
StrAssign(String T,char *chars)生成一个其值等于字符串常量chars的串T
StrCopy(String T,String S)复制串S到T
ClearString(String S)清空串
StrEmpty(String S)判断串是否为空
StrLength(String S)获取串S长度
Concat(String T,String S1,String S2)S1和S2连结成T
SubString(String Sub,String S,int pos,int len)用sub返回串s的第pos个字符起长度为len的子串
StrCompare(String S,String T)字符串比较
Index(String S,String T,int pos)返回子串T在主串S中第pos个字符之后的位置
StrInsert(String S,int pos,String T)在串S的第pos个字符之前插入串T
StrDelete(String S,int pos,int len)从串S中删除第pos个字符起长度为len的子串
Replace(String S,String T,String V)用V替换主串S中出现的所有与T相等的不重叠的子串
StrPrint(String T)输出字符串T




6.1.4 串的部分简单操作详解


1. 生成串T

生成一个其值等于字符串常量chars的串T实现步骤如下：

  • 首先判断chars数组是否超过数组最大长度
  • 将chars的长度存入T[0]处
  • 利用for循环，逐个将chars的字符复制到串T中

代码如下：

/*生成一个其值等于字符串常量chars的串T*/
Status StrAssign(String T,char *chars){
    int i;
    if(strlen(chars) > MAXSIZE)         //chars长度超过串T最大存储空间
        return ERROR;
    else{
        T[0] = strlen(chars);
        for(i=1;i<=T[0];i++)
            T[i] = *(chars+i-1);    //将chars赋值给T
        return OK;
    }
}


2. 复制串

串S存在，将串S复制得串T，用for循环将串S每个字符赋值给T即可，包括用来存长度的首元素。

代码如下：

/*串S存在，将串S复制得串T*/
Status StrCopy(String T,String S){
    for(int i=0;i<=S[0];i++){
        T[i] = S[i];
    }
    return OK;
}


3. 清空串

代码如下：

/*清空串*/
Status ClearString(String S){
    S[0] = 0;
    return OK;
}


4. 判断串是否为空

判断串空利用串的首元素索引就可以，代码如下：

/*判断串是否为空*/
Status StrEmpty(String S){
    if(S[0]==0)
        return TRUE;
    else
        return FALSE;
}


5. 获取串长度

S[0]处存放了串S的长度，代码如下：

/*返回长度*/
int StrLength(String S){
    return S[0];
}


6. 连结串

用T返回S1，S2连结而成的新串 若未截断返回TRUE，否则FALSE。

  • 未截断的判断条件 S1[0]+S2[0]<=MAXSIZE
  • 截断的判断条件 S1[0]+S2[0]>MAXSIZE

代码如下：

Status Concat(String T,String S1,String S2){
    int i;
    if(S1[0]+S2[0]<=MAXSIZE){
        //未截断
        for(i=1;i<=S1[0];i++)
            T[i] = S1[i];
        for(i=1;i<=S2[0];i++)
            T[S1[0]+i] = S2[i];
        T[0] = S1[0]+S2[0];
        return TRUE;
    }else{
        //截断S2
        for(i=1;i<=S1[0];i++)
            T[i] = S1[i];
        for(i=1;i<=MAXSIZE-S1[0];i++)
            T[S1[0]+i] = S2[i];
        T[0] = MAXSIZE;
        return FALSE;
    }
}


7. 获取子串

用sub返回串s的第pos个字符起长度为len的子串，代码如下：

Status SubString(String Sub,String S,int pos,int len){
    int i;
    if(pos<1 || pos>S[0] || len<0 || len>S[0] || len>S[0]-pos+1)
        return ERROR;
    for(i=1;i<=len;i++)
        Sub[i] = S[pos+i-1];
    Sub[0] = len;
    return OK;
}

特别注意，if语句里面的内容，pos和len必须在一定范围内。

8. 比较两串

代码如下：

/*字符串比较 若S>T，返回值>0，若S<T，返回值<0，S=T,返回值=0*/
int StrCompare(String S,String T){
    for(int i=1;i<=S[0]&&i<=T[0];i++){
        if(S[i]!=T[i])
            return S[i]-T[i];
    }
    return S[0]-T[0];
}


9. 输出串

代码如下：

/*  输出字符串T */
void StrPrint(String T){ 
	int i;
	for(i=1;i<=T[0];i++)
		printf("%c",T[i]);
	printf("\n");
}




6.1.5 朴素的模式匹配算法



朴素的模式匹配算法就是一个在主串中找相匹配的子串的操作，图解如下：

在这里插入图片描述

  • 当S[i]!=T[j]时，j回到串的第一个位置，即j=1，而i回到上一个匹配成功的首位的下一位。

  • 当S[i]=T[j]，i和j都加1，向前继续匹配。

  • 最后一个字符匹配完成后，i和j还要加1，最后返回子串T在主串S中第pos个字符(图中是第一个位置)之后的位置，i-T[0]，图中i-T[0]=5-2=3

代码如下：

/* 返回子串T在主串S中第pos个字符之后的位置。若不存在,则函数返回值为0。 */
/* 其中,T非空,1≤pos≤StrLength(S)。 */
int Index(String S,String T,int pos){
    int i = pos;
    int j = 1;
    while(i<=S[0] && j<=T[0]){
        if(S[i]==T[j]){
            //两字母相同则继续
            ++i;
            ++j;
        }else{
            //字母不同，指针后退重新开始匹配
            i = i-j+2;      //i回到上次匹配首位的下一位
            j = 1;          //j回到子串T首位
        }
    }
    if(j > T[0])
        return i-T[0];
    return 0;
}




6.1.6 串的插入

在串S的第pos个字符之前插入串T，这边有两种情况：

  • 完全插入，当S[0]+T[0]<=MAXSIZE
  • 部分插入

代码如下：

/*  初始条件: 串S和T存在,1≤pos≤StrLength(S)+1 */
/*  操作结果: 在串S的第pos个字符之前插入串T。完全插入返回TRUE,部分插入返回FALSE */
Status StrInsert(String S,int pos,String T){
    int i;
    if(pos<1 || pos>S[0]+1)
        return ERROR;
    if(S[0]+T[0]<=MAXSIZE){
        //完全插入
        for(i=S[0];i>=pos;i--)
            S[i+T[0]] = S[i];
        for(i=pos;i<pos+T[0];i++)
            S[i] = T[i-pos+1];
        S[0] = S[0]+T[0];
        return TRUE;
    }else{
        //部分插入
        for(i=MAXSIZE;i<=pos;i--)
			S[i]=S[i-T[0]];
		for(i=pos;i<pos+T[0];i++)
			S[i]=T[i-pos+1];
		S[0]=MAXSIZE;
		return FALSE;
    }
}




6.1.7 串的删除和替换


1. 删除子串

从串S中删除第pos个字符起长度为len的子串，代码如下：

/*  初始条件: 串S存在,1≤pos≤StrLength(S)-len+1 */
/*  操作结果: 从串S中删除第pos个字符起长度为len的子串 */
Status StrDelete(String S,int pos,int len){
    int i;
    if(pos<1 || pos>S[0]-len+1 || len<0)
        return ERROR;
    for(i=pos+len;i<=S[0];i++)
        S[i-len] = S[i];
    S[0]-=len;
    return OK;
}


2. 替换子串

用V替换主串S中出现的所有与T相等的不重叠的子串，这里会调用朴素的模式匹配算法来匹配子串。

代码如下：

/*  初始条件: 串S,T和V存在,T是非空串（此函数与串的存储结构无关） */
/*  操作结果: 用V替换主串S中出现的所有与T相等的不重叠的子串 */
Status Replace(String S,String T,String V){
    int i=1;        //从串S的第一个字符开始查找T

    if(StrEmpty(T)) //如果T是空串
        return ERROR;
    do{
        i = Index(S,T,i);       //i为从上一个i之后找到的子串T的位置

        if(i){      //S中找到串T了
            StrDelete(S,i,StrLength(T));    //删除该串
            StrInsert(S,i,V);
            i+=StrLength(V);
        }
    } while (i);
    return OK;
}




6.1.8 测试



测试代码：

int main(){
	
	int i,j;
	Status k;
	char s;
	String t,s1,s2;
	printf("请输入串s1: ");
	
	k=StrAssign(s1,"abcd");
	if(!k)
	{
		printf("串长超过MAXSIZE(=%d)\n",MAXSIZE);
		exit(0);
	}
	printf("串长为%d 串空否？%d(1:是 0:否)\n",StrLength(s1),StrEmpty(s1));
	StrCopy(s2,s1);
	printf("拷贝s1生成的串为: ");
	StrPrint(s2);
	printf("请输入串s2: ");
	
	k=StrAssign(s2,"efghijk");
	if(!k)
	{
		printf("串长超过MAXSIZE(%d)\n",MAXSIZE);
		exit(0);
	}
	i=StrCompare(s1,s2);
	if(i<0)
		s='<';
	else if(i==0)
		s='=';
	else
		s='>';
	printf("串s1%c串s2\n",s);
	k=Concat(t,s1,s2);
	printf("串s1联接串s2得到的串t为: ");
	StrPrint(t);
	if(k==FALSE)
		printf("串t有截断\n");
	ClearString(s1);
	printf("清为空串后,串s1为: ");
	StrPrint(s1);
	printf("串长为%d 串空否？%d(1:是 0:否)\n",StrLength(s1),StrEmpty(s1));
	printf("求串t的子串,请输入子串的起始位置,子串长度: ");

	i=2;
	j=3;
	printf("%d,%d \n",i,j);

	k=SubString(s2,t,i,j);
	if(k)
	{
		printf("子串s2为: ");
		StrPrint(s2);
	}
	printf("从串t的第pos个字符起,删除len个字符，请输入pos,len: ");
	
	i=4;
	j=2;
	printf("%d,%d \n",i,j);


	StrDelete(t,i,j);
	printf("删除后的串t为: ");
	StrPrint(t);
	i=StrLength(s2)/2;
	StrInsert(s2,i,t);
	printf("在串s2的第%d个字符之前插入串t后,串s2为:\n",i);
	StrPrint(s2);
	i=Index(s2,t,1);
	printf("s2的第%d个字母起和t第一次匹配\n",i);
	SubString(t,s2,1,1);
	printf("串t为：");
	StrPrint(t);
	Concat(s1,t,t);
	printf("串s1为：");
	StrPrint(s1);
	Replace(s2,t,s1);
	printf("用串s1取代串s2中和串t相同的不重叠的串后,串s2为: ");
	StrPrint(s2);

	system("pause");
	return 0;
}


运行结果：

请输入串s1: 串长为4 串空否？0(1:是 0:否)
拷贝s1生成的串为: abcd
请输入串s2: 串s1<串s2
串s1联接串s2得到的串t为: abcdefghijk
清为空串后,串s1为:
串长为0 串空否？1(1:是 0:否)
求串t的子串,请输入子串的起始位置,子串长度: 2,3
子串s2为: bcd
从串t的第pos个字符起,删除len个字符，请输入pos,len: 4,2
删除后的串t为: abcfghijk
在串s2的第1个字符之前插入串t后,串s2为:
abcfghijkbcd
s2的第1个字母起和t第一次匹配
串t为：a
串s1为：aa
用串s1取代串s2中和串t相同的不重叠的串后,串s2为: aabcfghijkbcd
请按任意键继续. . .




6.1.9 完整代码



下面附上完整代码：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 40

typedef int Status;
typedef int ElemType;

typedef char String[MAXSIZE+1];     //0号单元存放串的长度

/*生成一个其值等于字符串常量chars的串T*/
Status StrAssign(String T,char *chars){
    int i;
    if(strlen(chars) > MAXSIZE)         //chars长度超过串T最大存储空间
        return ERROR;
    else{
        T[0] = strlen(chars);
        for(i=1;i<=T[0];i++)
            T[i] = *(chars+i-1);    //将chars赋值给T
        return OK;
    }
}

/*串S存在，将串S复制得串T*/
Status StrCopy(String T,String S){
    for(int i=0;i<=S[0];i++){
        T[i] = S[i];
    }
    return OK;
}

/*清空串*/
Status ClearString(String S){
    S[0] = 0;
    return OK;
}

/*判断串是否为空*/
Status StrEmpty(String S){
    if(S[0]==0)
        return TRUE;
    else
        return FALSE;
}


/*返回长度*/
int StrLength(String S){
    return S[0];
}

/*字符串比较 若S>T，返回值>0，若S<T，返回值<0，S=T,返回值=0*/
int StrCompare(String S,String T){
    for(int i=1;i<=S[0]&&i<=T[0];i++){
        if(S[i]!=T[i])
            return S[i]-T[i];
    }
    return S[0]-T[0];
}


/*用T返回S1，S2连结而成的新串 若未截断返回TRUE，否则FALSE*/
Status Concat(String T,String S1,String S2){
    int i;
    if(S1[0]+S2[0]<=MAXSIZE){
        //未截断
        for(i=1;i<=S1[0];i++)
            T[i] = S1[i];
        for(i=1;i<=S2[0];i++)
            T[S1[0]+i] = S2[i];
        T[0] = S1[0]+S2[0];
        return TRUE;
    }else{
        //截断S2
        for(i=1;i<=S1[0];i++)
            T[i] = S1[i];
        for(i=1;i<=MAXSIZE-S1[0];i++)
            T[S1[0]+i] = S2[i];
        T[0] = MAXSIZE;
        return FALSE;
    }
}

/*用sub返回串s的第pos个字符起长度为len的子串*/
Status SubString(String Sub,String S,int pos,int len){
    int i;
    if(pos<1 || pos>S[0] || len<0 || len>S[0] || len>S[0]-pos+1)
        return ERROR;
    for(i=1;i<=len;i++)
        Sub[i] = S[pos+i-1];
    Sub[0] = len;
    return OK;
}


/* 返回子串T在主串S中第pos个字符之后的位置。若不存在,则函数返回值为0。 */
/* 其中,T非空,1≤pos≤StrLength(S)。 */
int Index(String S,String T,int pos){
    int i = pos;
    int j = 1;
    while(i<=S[0] && j<=T[0]){
        if(S[i]==T[j]){
            //两字母相同则继续
            ++i;
            ++j;
        }else{
            //字母不同，指针后退重新开始匹配
            i = i-j+2;      //i回到上次匹配首位的下一位
            j = 1;          //j回到子串T首位
        }
    }
    if(j > T[0])
        return i-T[0];
    return 0;
}


/*  初始条件: 串S和T存在,1≤pos≤StrLength(S)+1 */
/*  操作结果: 在串S的第pos个字符之前插入串T。完全插入返回TRUE,部分插入返回FALSE */
Status StrInsert(String S,int pos,String T){
    int i;
    if(pos<1 || pos>S[0]+1)
        return ERROR;
    if(S[0]+T[0]<=MAXSIZE){
        //完全插入
        for(i=S[0];i>=pos;i--)
            S[i+T[0]] = S[i];
        for(i=pos;i<pos+T[0];i++)
            S[i] = T[i-pos+1];
        S[0] = S[0]+T[0];
        return TRUE;
    }else{
        //部分插入
        for(i=MAXSIZE;i<=pos;i--)
			S[i]=S[i-T[0]];
		for(i=pos;i<pos+T[0];i++)
			S[i]=T[i-pos+1];
		S[0]=MAXSIZE;
		return FALSE;
    }
}


/*  初始条件: 串S存在,1≤pos≤StrLength(S)-len+1 */
/*  操作结果: 从串S中删除第pos个字符起长度为len的子串 */
Status StrDelete(String S,int pos,int len){
    int i;
    if(pos<1 || pos>S[0]-len+1 || len<0)
        return ERROR;
    for(i=pos+len;i<=S[0];i++)
        S[i-len] = S[i];
    S[0]-=len;
    return OK;
}


/*  初始条件: 串S,T和V存在,T是非空串（此函数与串的存储结构无关） */
/*  操作结果: 用V替换主串S中出现的所有与T相等的不重叠的子串 */
Status Replace(String S,String T,String V){
    int i=1;        //从串S的第一个字符开始查找T

    if(StrEmpty(T)) //如果T是空串
        return ERROR;
    do{
        i = Index(S,T,i);       //i为从上一个i之后找到的子串T的位置

        if(i){      //S中找到串T了
            StrDelete(S,i,StrLength(T));    //删除该串
            StrInsert(S,i,V);
            i+=StrLength(V);
        }
    } while (i);
    return OK;
}

/*  输出字符串T */
void StrPrint(String T){ 
	int i;
	for(i=1;i<=T[0];i++)
		printf("%c",T[i]);
	printf("\n");
}

int main(){
	
	int i,j;
	Status k;
	char s;
	String t,s1,s2;
	printf("请输入串s1: ");
	
	k=StrAssign(s1,"abcd");
	if(!k)
	{
		printf("串长超过MAXSIZE(=%d)\n",MAXSIZE);
		exit(0);
	}
	printf("串长为%d 串空否？%d(1:是 0:否)\n",StrLength(s1),StrEmpty(s1));
	StrCopy(s2,s1);
	printf("拷贝s1生成的串为: ");
	StrPrint(s2);
	printf("请输入串s2: ");
	
	k=StrAssign(s2,"efghijk");
	if(!k)
	{
		printf("串长超过MAXSIZE(%d)\n",MAXSIZE);
		exit(0);
	}
	i=StrCompare(s1,s2);
	if(i<0)
		s='<';
	else if(i==0)
		s='=';
	else
		s='>';
	printf("串s1%c串s2\n",s);
	k=Concat(t,s1,s2);
	printf("串s1联接串s2得到的串t为: ");
	StrPrint(t);
	if(k==FALSE)
		printf("串t有截断\n");
	ClearString(s1);
	printf("清为空串后,串s1为: ");
	StrPrint(s1);
	printf("串长为%d 串空否？%d(1:是 0:否)\n",StrLength(s1),StrEmpty(s1));
	printf("求串t的子串,请输入子串的起始位置,子串长度: ");

	i=2;
	j=3;
	printf("%d,%d \n",i,j);

	k=SubString(s2,t,i,j);
	if(k)
	{
		printf("子串s2为: ");
		StrPrint(s2);
	}
	printf("从串t的第pos个字符起,删除len个字符，请输入pos,len: ");
	
	i=4;
	j=2;
	printf("%d,%d \n",i,j);


	StrDelete(t,i,j);
	printf("删除后的串t为: ");
	StrPrint(t);
	i=StrLength(s2)/2;
	StrInsert(s2,i,t);
	printf("在串s2的第%d个字符之前插入串t后,串s2为:\n",i);
	StrPrint(s2);
	i=Index(s2,t,1);
	printf("s2的第%d个字母起和t第一次匹配\n",i);
	SubString(t,s2,1,1);
	printf("串t为：");
	StrPrint(t);
	Concat(s1,t,t);
	printf("串s1为：");
	StrPrint(s1);
	Replace(s2,t,s1);
	printf("用串s1取代串s2中和串t相同的不重叠的串后,串s2为: ");
	StrPrint(s2);

	system("pause");
	return 0;
}

6.1.10 总结

从这节，我们学会了朴素的模式匹配算法，但是一但匹配的长度上去了，这种算法太低效，因为当匹配不成功，主串的i总是要回到首次匹配的下一位置，而不是直接到匹配失败的位置，下一节，会补充解决这种方式的算法-----KMP匹配算法。

压力小子呀
关注
专栏目录
串的模式匹配算法 – BF算法详解
CoutCodes的博客
03-19 4286
文章目录一、BF算法原理设计思想：二、时间复杂度三、C++实现代码 一、BF算法原理 BF算法是一种蛮力算法，其实现过程没有任何技巧，就是简单粗暴地拿一个串同另一个串中的字符一一比对，得到最终结果。 算法目的：确定主串中所含子串第一次出现的位置，这里的子串也称为模式串。 设计思想： （1）主串和模式串逐个字符进行比较 （2）当出现字符不匹配（失配）时，主串的比较位置重置为起始位置的...
【课件】4.2.1_朴素模式匹配算法.pdf
05-16
### 朴素模式匹配算法知识点详解 #### 一、朴素模式匹配算法概述 朴素模式匹配算法是一种基础的字符串匹配算法，其基本思想是将一个模式串（即待查找的字符串）在主串（即待搜索的大字符串）中进行逐个字符比较，...
串的朴素模式匹配算法
weixin_52442312的博客
12-15 300
串的朴素模式匹配算法详解
串的模式匹配算法(KMP算法，BF算法+算法详解+实现代码)
冲出仁川，走出马德里，故事还会再继续
06-10 1万+
串的模式匹配算法(KMP算法，BF算法+算法详解+实现代码) 子串的定位操作是找子串在主串中从第pos个字符后首次出现的位置，又被称为串的模式匹配 一、BF模式匹配算法 BF算法思想:Brute-Force算法又称蛮力匹配算法(简称BF算法),从主串S的第pos个字符开始，和模式串T的第一个字符进行比较，若相等，则继续比较后续字符；否则回溯到主串S的第pos+1个字符开始重新和模式串T进行比较。以此类推，直至模式串T中的每一个字符依次和主串S中的一个连续的字符序列相等，则称模式匹配成功，此时返回模式串T
串的基本概念详解，串的模式匹配算法详解（暴力模式匹配算法详解、C++代码实现；KMP算法详解、C++代码实现）
weixin_45651616的博客
07-10 1133
数据结构，串的定义和实现详解，模式匹配算法详解（暴力模式匹配算法详解和C++代码实现，KMP算法详解和C++代码实现）
c语言朴素的模式匹配次数计算,快速模式匹配算法(KMP)的深入理解
weixin_32200329的博客
05-18 907
恐怕现在用过电脑的人，一定都知道大部分带文本编辑功能的软件都有一个快捷键ctrl+f 吧(比如word)。这个功能主要来完成“查找”，“替换”和“全部替换”功能的，其实这就是典型的模式匹配的应用，即在文本文件中查找串。1.模式匹配模式匹配的模型大概是这样的：给定两个字符串变量S和P，其中S成为目标串，其中包含n个字符，P称为模式串，包含m个字符，其中m<=n。从S的给定位置(通常是S的第一个...
python模式匹配算法_BF算法（串模式匹配算法）C语言详解
weixin_39957271的博客
12-06 595
串的模式匹配算法，通俗地理解，是一种用来判断两个串之间是否具有"主串与子串"关系的算法。主串与子串：如果串 A(如 "shujujiegou")中包含有串 B(如 "ju")，则称串 A 为主串，串 B 为子串。主串与子串之间的关系可简单理解为一个串 "包含" 另一个串的关系。实现串的模式匹配的算法主要有以下两种：普通的模式匹配算法；快速模式匹配算法；本节，先来学习普通模式匹配(BF)算法的实现。...
串的模式匹配算法-暴力、KMP算法详解
Nick_Jackson的博客
09-22 828
串的模式匹配算法-KMP算法 简介 KMP算法是一种改进的字符串匹配算法，由D.E.Knuth，J.H.Morris和V.R.Pratt提出的，因此人们称它为克努特—莫里斯—普拉特操作（简称KMP算法）。KMP算法的核心是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。具体实现就是通过一个next()函数实现，函数本身包含了模式串的局部匹配信息。 简单的模式匹配算法（暴力匹配算法） 假设现在我们面临这样一个问题：有一个文本串S，和一个模式串P，现在要查找P在S中的位置，如何查找呢？
KMP模式匹配算法详解（Java实现）
孙宇航的博客
05-28 844
KMP算法是一种改进的字符串匹配算法，由D.E.Knuth，J.H.Morris和V.R.Pratt提出的，因此人们称它为克努特—莫里斯—普拉特操作（简称KMP算法）。 KMP算法的核心是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。 具体实现就是通过一个next()函数实现，函数本身包含了模式串的局部匹配信息。KMP算法的时间复杂度O(m+n) 文字来源：百度百科 目录 具体实现： 原理： next数组： 总结 具体实现： x指针：用来做主串索引，y指.
遗传算法（Genetic Algorithm）详解与实现
热门推荐
盼小辉丶的博客
12-25 15万+
遗传算法（Genetic Algorithm, GA）是受自然进化原理启发的一系列搜索算法。通过模仿自然选择和繁殖的过程，遗传算法可以为涉及搜索、优化和学习的各种问题提供高质量的解决方案。同时，它们类似于自然进化，因此遗传算法可以克服传统搜索和优化算法遇到的一些障碍，尤其是对于具有大量参数和复杂数学表示形式的问题。
字符串匹配代码C语言,KMP算法(快速模式匹配算法)详解以及C语言实现
weixin_42546508的博客
05-17 1344
通过上一节的介绍，学习了普通模式匹配算法，大体思路是：模式串从主串的第一个字符开始匹配，每匹配失败，主串中记录匹配进度的指针 i 都要进行 i-j+1 的回退操作(这个过程称为“指针回溯”)，同时模式串向后移动一个字符的位置。一次次的循环，直到匹配成功或者程序结束。"KMP"算法相比于"BF"算法，优势在于：在保证指针 i 不回溯的前提下，当匹配失败时，让模式串向右移动最大的距离；并且可以在O(n...
字符串的模式匹配详解--BF算法与KMP算法
09-04
本文主要探讨两种经典的模式匹配算法：BF（Brute Force，暴力匹配）算法和KMP（Knuth-Morris-Pratt，克努斯-莫里斯-普拉特）算法。 **BF算法**是最基础的模式匹配方法，它的核心思想是对每一个可能的子串进行匹配...
java 中模式匹配算法-KMP算法实例详解
08-30
"java 中模式匹配算法-KMP 算法实例详解" 在 Java 中，模式匹配算法是一种常用的字符串匹配算法，KMP 算法是一种高效的模式匹配算法。下面是 KMP 算法的知识点总结： 1. 朴素模式匹配算法的缺陷：朴素模式匹配算法...
dp算法练习【7】
MADAO的博客
09-08 1423
给你一个按排序的整数数组nums，返回组成的新数组，要求也按排序。平方后，数组变为 [16,1,0,9,100]排序后，数组变为 [0,1,9,16,100]非常简单，思路平方后排序。优化：插入法。
深度优先算法，广度优先算法，hill climbing，贪心搜索，A*算法，启发式搜索算法是什么，比起一般搜索法算法有什么区别
mimo_mimo的博客
09-10 1116
A算法通过维护一个优先队列（通常是最小堆），并根据启发式函数（如g(n) + h(n)，其中g(n)是从起点到当前点的实际距离，h(n)是从当前点到目标点的估计距离）来评估节点的优先级。它从图的某个顶点V0开始，依次访问V0的各个未被访问过的邻接点，然后从这些邻接点出发，再依次访问它们的未被访问过的邻接点，直到图中所有已被访问过的顶点的邻接点都被访问到。它从当前的节点开始，和周围的邻居节点的值进行比较，如果当前节点不是最大的，就用最高的邻居节点来替换当前节点，从而实现向“山峰”的高处攀爬的目的。
洛谷刷题之B2089 数组逆序重存放
resco的博客
09-07 1199
洛谷刷题之B2089 数组逆序重存放
算法练习题22——解码
hello77的blogggg 祝你得偿所愿
09-11 347
小明有一串很长的英文字母，其中可能包含大写和小写字母。在这串字母中，有很多字母是连续且重复的。为了压缩这串字母的表达形式，小明决定将连续相同的字母用“字母 + 出现次数”的形式表示。
代码随想录算法训练营day18|二叉树06
gyuhyhui的博客
09-10 742
示例 2: 输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 输出: 5 解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。那么我们来说一说，如果 root == q，或者 root == p，说明找到 q p ，则将其返回，这个返回值，后面在中节点的处理过程中会用到，那么中节点的处理逻辑，下面讲解。例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]
二分系列(二分查找)9/12
最新发布
2301_78191305的博客
09-12 870
排序数组->使用二分。第一个位置:>=；第二个位置:=(target+1)-1；所以直接写一个>=的函数。
单链表实现串模式匹配算法详解
本资源主要讨论了如何通过带头结点的单链表实现串（String）的模式匹配算法，这是数据结构中的一个重要应用。串在计算机科学中是一种基本的数据结构，它是由零个或多个字符组成的有限序列，可以用字符数组或链表形式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

压力小子呀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值