_DataStructure_C_Impl:KMP模式匹配

#include<stdio.h>
#include<stdlib.h>
#include<string.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);
void GetNext(SeqString T,int next[]);
void GetNextVal(SeqString T,int nextval[]);
void PrintArray(SeqString T,int next[],int nextval[],int length);
void 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("Brute-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("Brute-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);
	system("pause");
}
//在主串S中的第pos个位置开始查找子串T，如果找到返回子串在主串的位置；否则，返回-1
int B_FIndex(SeqString S,int pos,SeqString T,int *count){
	int i,j;
	i=pos-1;
	j=0;
	*count=0;		//count保存主串与模式串的比较次数
	while(i<S.length&&j<T.length){
		if(S.str[i]==T.str[j]){	//如果串S和串T中对应位置字符相等，则继续比较下一个字符
			i++;
			j++;
		}else{		//如果当前对应位置的字符不相等，则从串S的下一个字符开始，T的第0个字符开始比较
			i=i-j+1;
			j=0;
		}
		(*count)++;
	}
	if(j>=T.length)
		return i-j+1;		//如果在S中找到串T，则返回子串T在主串S的位置
	else
		return -1;
}
//KMP模式匹配算法。利用模式串T的next函数在主串S中的第pos个位置开始查找子串T，如果找到返回子串在主串的位置；否则，返回-1
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.length&&j<T.length){
		if(j==-1||S.str[i]==T.str[j]){
			i++;
			j++;
		}else
			j=next[j];
		(*count)++;
	}
	if(j>=T.length)
		return i-T.length+1;
	else
		return -1;
}
//求模式串T的next函数值并存入数组next
void GetNext(SeqString T,int next[]){
	int j,k;
	j=0;
	k=-1;
	next[0]=-1;
	while(j<T.length){
		if(k==-1||T.str[j]==T.str[k]){		//如果k=-1或当前字符相等，则继续比较后面的字符并将函数值存入到next数组
			j++;
			k++;
			next[j]=k;
		}else
			k=next[k];	//如果当前字符不相等，则将模式串向右移动继续比较
	}
}
//求模式串T的next函数值的修正值并存入数组next
void GetNextVal(SeqString T,int nextval[]){
	int j,k;
	j=0;
	k=-1;
	nextval[0]=-1;
	while(j<T.length){
		if(k==-1||T.str[j]==T.str[k]){	//如果k=-1或当前字符相等，则继续比较后面的字符并将函数值存入到nextval数组
			j++;
			k++;
			if(T.str[j]!=T.str[k])		//如果所求的nextval[j]与已有的nextval[k]不相等，则将k存放在nextval中
				nextval[j]=k;
			else
				nextval[j]=nextval[k];
		}else			//如果当前字符不相等，则将模式串向右移动继续比较
			k=nextval[k];
	}
}
//模式串T的next值与nextval值输出函数
void PrintArray(SeqString T,int next[],int nextval[],int length){
	int j;
	printf("j:\t\t");
	for(j=0;j<length;j++)
		printf("%3d",j);
	printf("\n");
	printf("模式串:\t\t");
	for(j=0;j<length;j++)
		printf("%3c",T.str[j]);
	printf("\n");
	printf("next[j]:\t");
	for(j=0;j<length;j++)
		printf("%3d",next[j]);
	printf("\n");
	printf("nextval[j]:\t");
	for(j=0;j<length;j++)
		printf("%3d",nextval[j]);
	printf("\n");
}

#pragma once
#include<stdio.h>
#include<stdlib.h>
#define MaxLength 60
typedef struct{
	char str[MaxLength];
	int length;
}SeqString;
//串的赋值操作
void StrAssign(SeqString *S,char cstr[]){
	int i;
	for(i=0;cstr[i]!='\0';i++)
		S->str[i]=cstr[i];	//将常量cstr中的字符赋值给串S
	S->length=i;
}
//判断串是否为空，串为空返回1，否则返回0
int StrEmpty(SeqString S){
	if(S.length==0)
		return 1;
	else
		return 0;
}
//求串的长度操作
int StrLength(SeqString S){
	return S.length;
}
//串的复制操作
void StrCopy(SeqString *T,SeqString S){
	int i;
	for(i=0;i<S.length;i++)	//将串S的字符赋值给串T
		T->str[i]=S.str[i];
	T->length=S.length;	//将串S的长度赋值给串T
}
//串的比较操作
int StrCompare(SeqString S,SeqString T){	//比较两个串中的字符
	int i;
	for(i=0;i<S.length&&i<T.length;i++){		//比较两个串中的字符
		if(S.str[i]!=T.str[i])		//如果出现字符不同，则返回两个字符的差值
			return (S.str[i]-T.str[i]);
	}
	return (S.length-T.length);	//如果比较完毕，返回两个串的长度的差值
}
//串的插入操作。在S中第pos个位置插入T分为三种情况
int StrInsert(SeqString *S,int pos,SeqString T){
	int i;
	if(pos<0||pos-1>S->length){	//插入位置不正确，返回0
		printf("插入位置不正确");
		return 0;
	}
	if(S->length+T.length<=MaxLength){	//第一种情况，插入子串后串长≤MaxLength，即子串T完整地插入到串S中
		for(i=S->length+T.length-1;i>=pos+T.length-1;i--)	//在插入子串T前，将S中pos后的字符向后移动len个位置
			S->str[i]=S->str[i-T.length];
		for(i=0;i<T.length;i++)	//将串插入到S中
			S->str[pos+i-1]=T.str[i];
		S->length=S->length+T.length;
		return 1;
	}else if(pos+T.length<=MaxLength){	//第二种情况，子串可以完全插入到S中，但是S中的字符将会被截掉
		for(i=MaxLength-1;i>T.length+pos-i;i--)		//将S中pos以后的字符整体移动到数组的最后
			S->str[i]=S->str[i-T.length];
		for(i=0;i<T.length;i++)		//将T插入到S中
			S->str[i+pos-1]=T.str[i];
		S->length=MaxLength;
		return 0;
	}else{		//第三种情况，子串T不能被完全插入到S中，T中将会有字符被舍弃
		for(i=0;i<MaxLength-pos;i++)	//将T直接插入到S中，插入之前不需要移动S中的字符
			S->str[i+pos-1]=T.str[i];
		S->length=MaxLength;
		return 0;
	}
}
//在串S中删除pos开始的len个字符
int StrDelete(SeqString *S,int pos,int len){
	int i;
	if(pos<0||len<0||pos+len-1>S->length){
		printf("删除位置不正确，参数len不合法");
		return 0;
	}else{
		for(i=pos+len;i<=S->length-1;i++)
			S->str[i-len]=S->str[i];
		S->length=S->length-len;
		return 1;
	}
}
//串的连接操作
int StrCat(SeqString *T,SeqString S){
	int i,flag;
	if(T->length+S.length<=MaxLength){
		for(i=T->length;i<T->length+S.length;i++)
			T->str[i]=S.str[i-T->length];
		T->length=T->length+S.length;
		flag=1;
	}else if(T->length<MaxLength){
		for(i=T->length;i<MaxLength;i++)
			T->str[i]=S.str[i-T->length];
		T->length=MaxLength;
		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.length){
		printf("参数pos和len不合法");
		return 0;
	}else{
		for(i=0;i<len;i++)
			Sub->str[i]=S.str[i+pos-1];
		Sub->length=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.length&&j<T.length){
		if(S.str[i]==T.str[j]){
			i++;
			j++;
		}else{
			i=i-j+1;
			j=0;
		}
	}
	if(j>=T.length)
		return i-j+1;
	else
		return 0;
}
//串的替换操作
int StrReplace(SeqString *S,SeqString T,SeqString V){
	//将S中所有的T替换为V
	int i;
	int flag;
	if(StrEmpty(T))
		return 0;
	i=0;
	do{
		i=StrIndex(*S,i,T);//找到T在S中的位置
		if(i){
			StrDelete(S,i,StrLength(T));	//删除找到的T
			flag=StrInsert(S,i,V);	//在i位置插入V
			if(!flag)
				return 0;
			i+=StrLength(V);
		}
	}while(i);
	return 1;
}
//串的清空操作
void StrClear(SeqString *S){
	S->length=0;
}
//===========
void StrPrint(SeqString S){
	int i;
	for(i=0;i<S.length;i++){
		printf("%c",S.str[i]);
	}
	printf("\n");
}

时间： 2024-10-10 02:47:06

_DataStructure_C_Impl:KMP模式匹配的相关文章

KMP模式匹配_2

http://blog.csdn.net/lin_bei/article/details/1252686 个人觉得这篇文章是网上的介绍有关KMP算法更让人容易理解的文章了,确实说得很“详细”,耐心地把它看完肯定会有所收获的--,另外有关模式函数值next[i]确实有很多版本啊,在另外一些面向对象的算法描述书中也有失效函数 f(j)的说法,其实是一个意思,即next[j]=f(j-1)+1,不过还是next[j]这种表示法好理解啊: KMP字符串模式匹配详解 KMP字符串模式匹配通俗点说就是一种在

KMP算法 KMP模式匹配二（串）

B - KMP模式匹配二(串) Crawling in process... Crawling failed Time Limit:1000MS Memory Limit:131072KB 64bit IO Format:%lld & %llu Description 输入一个主串和一个子串,用KMP进行匹配,问进行几趟匹配才成功,若没成功,则输出0 Input 输入一个主串和一个子串 Output 匹配的趟数 Sample Input ababcabcacbab abcac

KMP算法 KMP模式匹配一（串）

A - KMP模式匹配一(串) Crawling in process... Crawling failed Time Limit:1000MS Memory Limit:131072KB 64bit IO Format:%lld & %llu Description 求子串的next值,用next数组存放,全部输出 Input 输入一个字符串 Output 输出所有next值 Sample Input abaabcac Sample Output 0 1 1 2 2 3 1

KMP模式匹配

在开发中经常遇到需要查看一个字符串t是否在字符串s中存在,并找到其第一次出现的位置,也就是在字符串s中查找子串t,我们平常都是怎么实现那?我们最起码有三个方法可以用,CString和string中的find函数,以及string.h中的strstr函数,用起来既简单又快捷,CString是MFC中的东西,string是C++标准库的东西,strstr是C中string.h中的东西,貌似我们没必要非要自己实现定位查找功能--但是如果我偏要想自己实现那?我们能不能模仿MFC中的CString或者C+

KMP练习——KMP模式匹配一（串）

Description 求子串的next值,用next数组存放,所有输出 Input 输入一个字符串 Output 输出全部next值 Sample Input abaabcac Sample Output 0 1 1 2 2 3 1 2 代码 #include<iostream> #include<cstdio> #include<cstring> #include<cmath> using namespace std; void getNext(char

字符串模式匹配之KMP算法图解与 next 数组原理和实现方案

之前说到,朴素的匹配,每趟比较,都要回溯主串的指针,费事.则 KMP 就是对朴素匹配的一种改进.正好复习一下. KMP 算法其改进思想在于: 每当一趟匹配过程中出现字符比较不相等时,不需要回溯主串的 i指针,而是利用已经得到的“部分匹配”的结果将模式子串向右“滑动”尽可能远的一段距离后,继续进行比较.如果 ok,那么主串的指示指针不回溯!算法的时间复杂度只和子串有关!很好. KMP算法的关键是利用匹配失败后的信息,尽量减少模式串与主串的匹配次数以达到快速匹配的目的,很自然的,需要一个函数来存储匹

KMP字符串模式匹配详解

KMP字符串模式匹配通俗点说就是一种在一个字符串中定位另一个串的高效算法.简单匹配算法的时间复杂度为O(m*n);KMP匹配算法.可以证明它的时间复杂度为O(m+n).. 一.简单匹配算法先来看一个简单匹配算法的函数: int Index_BF ( char S [ ], char T [ ], int pos ) { /* 若串 S 中从第pos(S 的下标0≤pos个字符起存在和串 T 相同的子串,则称匹配成功,返回第一个这样的子串在串 S 中的下标,否则返回 -1 */ int

[转]模式匹配之Brute-Force、KMP

(Brute-Force) 一.与串相关的概念 1.串(或字符串)是由零个或多个字符组成的有限序列.一般记作:s="c0c1c2…cn-1"(n≥0).零个字符的串称为空串,通常以两个相邻的双引号来表示空串,仅由空格组成的的串称为空格串,如:s=" ": 2.串与线性表的异同.字符串一般简称为串,可以将它看作是一种特殊的线性表,这种线性表的数据元素的类型总是字符型的,字符串的数据对象约束为字符集.在线性表的基本操作中,大多以“单个元素”作为操作对象,而在串中

（转）KMP字符串模式匹配详解

(转)KMP字符串模式匹配详解个人觉得这篇文章是网上的介绍有关KMP算法更让人容易理解的文章了,确实说得很“详细”,耐心地把它看完肯定会有所收获的--,另外有关模式函数值next[i]确实有很多版本啊,在另外一些面向对象的算法描述书中也有失效函数 f(j)的说法,其实是一个意思,即next[j]=f(j-1)+1,不过还是next[j]这种表示法好理解啊: KMP字符串模式匹配详解 KMP字符串模式匹配通俗点说就是一种在一个字符串中定位另一个串的高效算法.简单匹配算法的时间复杂度为O(m*n)