Brute-Force经典算法和KMP算法的优劣

最新推荐文章于 2023-04-02 12:37:34 发布
最新推荐文章于 2023-04-02 12:37:34 发布
阅读量318 收藏
点赞数
分类专栏： 数据结构和算法 文章标签： 算法 c++ 数据结构 KMP 串
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wh1236666/article/details/112254987
版权

写程序比较Brute-Force算法和KMP算法的效果。

SeqString.h

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
typedef char DataType;
#define MAXLEN 	100
typedef struct Squeue{
	DataType str[MAXLEN];
	int len;
}SeqString;
//串的赋值
void StrAssign(SeqString *S,DataType cstr[]){
	int i=0;
	for(i=0;cstr[i]!='\0';i++){
		S->str[i]=cstr[i];
	}
	S->len=i;
} 
//判断串是否为空
int StrEmpty(SeqString S){
	if(S.len==0)
		return 1;
	else
		return 0; 
} 
//串的长度
int StrLength(SeqString S){
	return S.len;
} 
//串的复制
void StrCopy(SeqString *T,SeqString S){
	int i;
	for(i=0;i<S.len;i++){
		T->str[i]=S.str[i];
	}
	T->len=S.len;
} 
//串的比较操作
int StrCompare(SeqString S,SeqString T){
	int i;
	for(i=0;i<S.len;i++){
		if(S.str[i]!=T.str[i]){
			return (S.str[i]-T.str[i]);
		}
	}
	return (S.len-T.len);
} 
//串的插入操作
int StrInsert(SeqString *S,int pos,SeqString T){
	int i;
	if(pos<0||pos-1>S->len){
		printf("插入位置不正确\n");
		return 0; 
	}
	//第一种情况，插入子串后串长<=MAXLEN，即子串T完整地插入到串S中 
	if(S->len+T.len<=MAXLEN){
		for(i=S->len+T.len-1;i>=pos+T.len-1;i--){
			S->str[i]=S->str[i-T.len];
		}
		for(i=0;i<T.len;i++){
			S->str[pos+i-1]=T.str[i];
		}
		S->len=S->len+T.len;
		return 1;
	}
	//第2种情况，子串可以完全插入到S中，但是S中的字符将会被截掉 
	else if(pos+T.len<=MAXLEN){
		for(i=MAXLEN-1;i>T.len+pos-1;i--){
			S->str[i]=S->str[i-T.len];
		}
		for(i=0;i<T.len;i++){
			S->str[pos+i-1]=T.str[i];
		}
		S->len=MAXLEN;
		return 0;
	}
	//第3种情况，子串T不能被完全插入到S中，T中将会有字符被舍弃 
	else{
		for(i=0;i<MAXLEN-pos;i++){
			S->str[pos+i-1]=T.str[i];
		}
		S->len=MAXLEN;
		return 0;
	}
} 
//串的删除
int StrDelete(SeqString *S,int pos,int len){
	int i;
	if(pos<0||len<0||pos+len-1>S->len){
		printf("删除位置不正确\n");
		return 0; 
	}else{
		for(i=pos+len-1;i<S->len-1;i++){
				S->str[i-len]=S->str[i];
		}
		S->len=S->len-len;
		return 1;
	}
} 
//串的连接操作
int StrConcat(SeqString *T,SeqString S){
	int i,flag;
	//第一种情况，连接后的串长小于等于 MAXLEN，将S直接连接在串T的末尾
	if(T->len+S.len<=MAXLEN){
		for(i=T->len;i<T->len+S.len;i++){
			T->str[i]=S.str[i-T->len];
		}
		T->len=T->len+S.len;
		flag=1;
	}
	//第二种情况，连接后的串长大于MAXLEN，S部分被连接在串T的末尾 
	else{
		for(i=T->len;i<MAXLEN;i++){
			T->str[i]=S.str[i-T->len];
		}
		T->len=MAXLEN;
		flag=0;
	}
	return flag; 
} 
//求子串操作
int SubString(SeqString *Sub,SeqString S,int pos,int len){
	int i;
	if(pos<0||len<0||pos+len-1>S.len){
		printf("参数不合法\n");
		return 0; 
	}else{
		for(i=0;i<len;i++){
			Sub->str[i]=S.str[i+pos-1];
		}
		Sub->len=len;
		return 1;
	}
} 
//串的定位操作
int  StrIndex(SeqString S,int pos,SeqString T){
	int i,j;
	if(StrEmpty(T))
		return 0;
	i=pos;
	j=0;
	while(i<S.len&&j<T.len){
		if(S.str[i]==T.str[j]){
			i++;
			j++;
		}else{
			i=i-j+1;
			j=0;
		}
	}
	if(j>=T.len)
		return i-j+1;
	else 
		return -1;
}
//串的替换操作
int StrReplace(SeqString *S,SeqString T,SeqString V){
	int i=0;
	int flag;
	if(StrEmpty(T))
		return 0;
	do{
		i=StrIndex(*S,i,T);
		if(i){
			StrDelete(S,i,StrLength(T));
			flag=StrInsert(S,i,V);
			if(!flag){
				return 0;
			}
			i+=StrLength(V);
		}
	}while(i);
	return 1;
} 
//清空串
void StrClear(SeqString *S){
	S->len=0;
}

算法.cpp

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#include"SeqString.h"
int B_FIndex(SeqString S,int pos,SeqString T,int *count);
int KMP_Index(SeqString S,int pos,SeqString T,int next[],int *count);
int GetNext(SeqString T,int next[]);
int GetNextVal(SeqString T,int nextval[]);
void PrintArray(SeqString T,int next[],int nextval[],int len);
int main(){
	SeqString S,T;
	int count1=0,count2=0,count3=0,find;
	int next[40],nextval[40];
	//第一个比较例子
	StrAssign(&S,"abaababaddecab");//给主串S赋值 
	StrAssign(&T,"abad");//给模式串T赋值 
	GetNext(T,next);//将next的函数值保存在next数组中
	GetNextVal(T,nextval);//将改进后的next函数值保存在nextval数组
	printf("模式串T的next和改进后的next值：\n");
	PrintArray(T,next,nextval,StrLength(T));//输出模式串T的next值和nextval值
	find=B_FIndex(S,1,T,&count1);//传统的模式串匹配 
	if(find>0){
		printf("Brue-Force算法的比较次数为：%2d\n",count1);
	} 
	find=KMP_Index(S,1,T,next,&count2);
	if(find>0){
		printf("利用next的KMP算法的比较次数为：%2d\n",count2);
	}
	find=KMP_Index(S,1,T,nextval,&count3);
	if(find>0){
		printf("利用nextval的KMP算法的比较次数为：%2d\n",count3);
	}
	
	//第二个比较例子
	 StrAssign(&S,"cbccccbcacbccbacbccbcbcbc");//给主串S赋值 
	StrAssign(&T,"cbccbcbc");//给模式串T赋值 
	GetNext(T,next);//将next的函数值保存在next数组中
	GetNextVal(T,nextval);//将改进后的next函数值保存在nextval数组
	printf("模式串T的next和改进后的next值：\n");
	PrintArray(T,next,nextval,StrLength(T));//输出模式串T的next值和nextval值
	find=B_FIndex(S,1,T,&count1);//传统的模式串匹配 
	if(find>0){
		printf("Brue-Force算法的比较次数为：%2d\n",count1);
	} 
	find=KMP_Index(S,1,T,next,&count2);
	if(find>0){
		printf("利用next的KMP算法的比较次数为：%2d\n",count2);
	}
	find=KMP_Index(S,1,T,nextval,&count3);
	if(find>0){
		printf("利用nextval的KMP算法的比较次数为：%2d\n",count3);
	}
	return 1;
}
void PrintArray(SeqString T,int next[],int nextval[],int len){
	int j;
	printf("j:\t\t");
	for(j=0;j<len;j++){
		printf("%3d",j);
	}
	printf("\n");
	printf("模式串:\t\t");
	for(j=0;j<len;j++){
		printf("%3c",T.str[j]);
	}
	printf("\n");
	printf("next[j]:\t");
	for(j=0;j<len;j++){
		printf("%3d",next[j]);
	} 
	printf("\n");
	printf("nextval[j]:\t");
	for(j=0;j<len;j++){
		printf("%3d",nextval[j]);
	} 
	printf("\n");
}
//Brute-Force算法 
int B_FIndex(SeqString S,int pos,SeqString T,int *count){
	int i,j;
	i=pos-1;
	j=0;
	*count=0;
	while(i<S.len&&j<T.len){
		if(S.str[i]==T.str[i]){
			i++;
			j++;
		}else{
			i=i-j+1;
			j=0;
		}
		(*count)++;
	}
	if(j>=T.len){
		return i-j+1;
	}else{
		return -1;
	}
}
//KMP算法 
int KMP_Index(SeqString S,int pos,SeqString T,int next[],int *count){
	int i,j;
	i=pos-1;
	j=0;
	*count=0;
	while(i<S.len&&j<T.len){
		if(j==-1||S.str[i]==T.str[j]){
			i++;
			j++;
		}else{
			j=next[j];
		}
		(*count)++;
	}
	if(j>=T.len){
		return i-T.len+1;
	}else{
		return -1;
	}
}
//改进算法
int GetNext(SeqString T,int next[]){
	int j,k;
	j=0;
	k=-1;
	next[0]=-1;
	while(j<T.len){
		if(k==-1||T.str[j]==T.str[k]){
			j++;
			k++;
			next[j]=k;
		}else{
			k=next[k];
		}
	}
}
int GetNextVal(SeqString T,int nextval[]){
	int j,k;
	j=0;
	k=-1;
	nextval[0]=-1;
	while(j<T.len){
		if(k==-1||T.str[j]==T.str[k]){
			j++;
			k++;
			if(T.str[j]!=T.str[k]){
				nextval[j]=k;
			}else{
				nextval[j]=nextval[k];
			}
		}else{
			k=nextval[k];
		}
	}
}

运行结果
在这里插入图片描述

神石石
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅谈KMP算法
XiaoK's Blog
07-21 723
前言 KMP算法用于解决字符串匹配问题，现有两个字符串 S 和 P，请求出字符串 P 在字符串 S 中首次出现的位置，通常 S 被称为文本串，P 被称为模式串. 我们规定字符串的下标从 0 开始，文本串 S 的长度为 nnn，模式串 P 的长度为 mmm. 在下面这个例子中，模式串 P 在 S 中首次出现的位置是 3. 暴力匹配 解决这个问题最直接的方法就是用模式串 P 的开头依次与文本串 S 中的每一个下标对齐，然后判断 S 和 P 的后续字符是否完全相等. 在最差的情况下，算法的复杂度是 O(nm)O
kmp算法总结
热门推荐
ddyyxx的程序员之路
11-20 1万+
搞ACM也有三年了，期间学习了不少算法，到12月把上海站打完也要成退役狗了。最近突然想把学过的一些算法回过头来好好总结一下，于是就有了我的算法总结系列。这是这个系列的开端，所以先写一个简单点的算法，以后会慢慢复习一些复杂的算法，最后还是希望自己能够坚持下去吧。 KMP算法 KMP算法是一种线性时间复杂度的字符串匹配算法，它是对BF（Brute-Force,最基本的字符串匹配算法）的改进。对
KMP算法缺陷
最新发布
qq_35516011的博客
04-02 436
但是对于只由两个字母组成的字符串，KMP算法的效率是最差的，因为在构造next数组的过程中，可能会出现大量的重复计算。当然，这种情况下的比较次数可能不是最少的，但是从整体来看，KMP 算法是一种比较高效的字符串匹配算法。如果当前失配元素和 next 数组下标对应子串元素一样，确实会有一些重复的比较，但这样的情况出现的概率并不高，而且在实际情况中对算法效率的影响不大，因此不会影响 KMP 算法的正确性和实用性。在使用KMP算法的时候，有时会发生失配元素和next下标子串对应元素会相同，这种情况相当于–白做。
数据结构与算法 KMP算法详解 以及与普通匹配优势比较
quique的博客
03-17 2238
大名鼎鼎的KMP算法 来吧今天我们一起搞懂它！???? 首先不太清楚KMP算法的可以戳这里！百度百科欢迎您~ KMP算法简介： KMP算法是一种改进的字符串匹配算法。KMP算法的核心是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。具体实现就是通过一个next()函数实现，函数本身包含了模式串的局部匹配信息。KMP算法的时间复杂度O(m+n)。（来源百度） 可以看到KMP算法它...
P94 例4-7 编程比较Brute-Force算法和KMP算法的实际比较次数。两个测试例子为： （1）S=”cddcdc”,T=”abcde” （2）S=”aaaaaaaa”,T=”aaaab”
AKK188888881的博客
10-09 441
P94 例4-7 编程比较Brute-Force算法和KMP算法的实际比较次数。两个测试例子为： （1）S=”cddcdc”,T=”abcde” （2）S=”aaaaaaaa”,T=”aaaab” 头文件：DString.h #include<stdio.h> #include<stdlib.h> #include<string.h> typedef struct { char *str; int maxLength; int length; }DString;
13.Brute-Force算法与KMP算法.ppt
03-02
13.Brute-Force算法与KMP算法.ppt
数据结构Brute-Force算法的实现.pdf
08-07
在数据结构和算法设计中，Brute-Force算法通常用于解决排序、搜索和匹配等问题。尽管Brute-Force算法在效率上往往不是最优的，但它易于实现，对于小规模数据集或简单问题，可以快速得到解决方案。 ### Brute-Force...
Brute-Force模式匹配算法
Alex_Madison的博客
03-25 3636
Brute-Force算法是一种简单、直观的模式匹配算法。 其实现方式是： 设 s 是主串， t 为模式串； i 为主串当前比较字符的下标；j 为模式串当前比较字符的下标。令 i 的初值为 start，j 的初值为 0 。从主串的第 start 个字符 ( i = start ) 起和模式串的第一个字符 ( j = 0 )比较,若相等,则继续逐个比较后续字符 ( i++，j++)；否则从主串的第二个字符起重新和模式串比较( i 返回到原位置加 1， j 返回到 0 )依此类推，直至模式串t中的每一个字符依次
brute-force
03-21
2. **测试数据**：包含各种输入数据，用于验证brute-force算法的正确性和效率。 3. **文档**：可能有关于如何使用这些代码、算法工作原理以及如何优化brute-force方法的说明。 4. **示例**：展示了如何应用brute-...
串的模式匹配算法-BF（Brute-Force）算法
[SZU_Crayon]
05-20 1837
Bruce-Force算法     1.思路：        简单暴力的一个算法，如果遇到字符不匹配，主串i指针回溯到本次匹配位置的下一个位置，而模式串则重新回到0（开始的位置），开始下一轮的匹配。         成功匹配的条件自然事模式串指针j走到头，也就是j=length-1，length为模式串长度。跳出循环表示为j=length     2.算法复杂度        O（n*m...
KMP算法
tuyu233的博客
09-21 967
  写本篇博客只是为了帮助自己总结一下KMP算法，在总结之前特别感谢这篇博文http://www.ruanyifeng.com/blog/2013/05/Knuth–Morris–Pratt_algorithm.html，因为我就是从那里学来的，这里只是换一下表达方式。 1、口述KMP算法的优点 2、字符串的前后缀概念 3、构造next数组的传统方法 4、KMP算法举例讲解 5、...
自除数C语言编码,数据结构（十六）模式匹配算法--Brute Force算法和KMP算法
weixin_29408705的博客
05-18 362
一、模式匹配串的查找定位操作(也称为串的模式匹配操作)指的是在当前串(主串)中寻找子串(模式串)的过程。若在主串中找到了一个和模式串相同的子串，则查找成功；若在主串中找不到与模式串相同的子串，则查找失败。两种主要的模式匹配算法是Brute Force算法和KMP算法。二、Brute Force算法1.Brute Force算法也被称为朴素的模式匹配算法，是一种简单、直观的模式匹配算法。简单来说，就...
程序员必须会的基本算法4-KMP字符串查找算法(以暴力查找算法的缺点为背景)
入梦镜
02-27 223
package basic; import org.junit.Test; public class KMP { /* * KMP算法:它是解决一个子字符串是否在文本字符串里面出现过的问题, * 如果出现过就返回最先出现的位置,否则返回-1,也叫字符串查找算法, * 在了解KMP算法之前先了解一下暴力匹配算法,详细的转到最下面阅读 * 下面说一下KMP算法 * 文本字符...
Brute-Force算法
weixin_34292402的博客
09-30 470
1 #include <iostream> 2 #include <string> 3 using namespace std; 4 5 int BF(const string& father, const string& son) //返回首次匹配的字符串中的第一个匹配的字符的下标 6 { 7...
模式匹配中Brute-Force与KMP算法关键提取
qq_41795143的博客
11-28 187
模式匹配中Brute-Force与KMP算法关键提取     模式匹配是串结构的一种操作方法，用于串的匹配。待匹配串称为主串（也叫目标串），执行串称为子串（也叫模式串）。模式匹配即查找主串中是否包含子串。 模式匹配有两大经典算法 Brute-Force与KMP Brute-Force    简单总结就是粗暴匹配，即子串从0开始与主串依次匹配，若匹配失败，则子串仍从0开始，主串起始位置+1。...
详解kmp算法
qq_51950769的博客
02-05 6628
1.朴素模式匹配 1.1基本思想： 从主串test 和子串pattern 的第一个字符开始，将两字符串的字符一一比对，如果出现某个字符不匹配，主串回溯到第二个字符，子串回溯到第一个字符再进行一一比对。如果出现某个字符不匹配，主串回溯到第三个字符，子串回溯到第一个字符再进行一一比对…循环一直到子串字符全部匹配成功。 1.2例如： 第一次：不匹配 第二次：主串从第2个字符，模式串从头开始，直到b与c不匹配 第三次：主串从第3个位置开始，模式串从头开始，a与c...
串的朴素算法和KMP模式匹配算法
IT_Quanwudi的博客
11-06 901
串的朴素算法和KMP模式匹配算法 串的朴素算法 （BF算法又称暴力搜索）：首先待匹配串与模式串首先左对齐，然后从左向右开始逐个进行匹配，如果出现失配情况，则从待匹配串下一个字符开始进行匹配，直到模式串匹配成功。 例如： 待匹配串：a b d a b c a b 模式串 ：a b c 开始进行匹配： BF算...
KMP算法实现及其匹配改进
Mastic_29的博客
03-07 603
----------------------------------Mastic----------------------------------------------------------------
牛牧讲解：Brute-Force与KMP算法在模式匹配中的应用
在这个章节中，学习者将深入理解两种经典的模式匹配算法：Brute-Force算法和KMP算法。 Brute-Force算法，也称为简单匹配算法，其核心思想是通过逐字符比较主串（S）与模式串（T）来寻找子串T在S中的位置。从S的第一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值