字符串匹配（浅）

最新推荐文章于 2024-06-16 17:15:00 发布
最新推荐文章于 2024-06-16 17:15:00 发布
阅读量166 收藏
点赞数 1
分类专栏： 字符串匹配 kmp 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57517390/article/details/118861501
版权

本文介绍两种字符串匹配的方法：BF算法（暴力匹配），KMP算法（进阶）

BF算法

暴力匹配，顾名思义就是一个一个的进行匹配，若匹配成功，则移动到下一位，否则进行回溯

分为主串与子串，从第一位开始校对，若比对失败，则子串回溯，主串移动到下一位

字符串的结构

typedef struct String
{
	char* data;//数据域
	int len;//串的长度
}String;

字符串的初始化

String是我们自己对结构体设置的别名

1.先new一个指针；并把它的data设为NULL，以防野指针；再设置它的长度为0

String* initString()
{
    String* s = new String;
    s->data = NULL;
    S->len = 0;
    return s;
}

字符串赋值

将传入的字符数组赋值给串，我们需要字符数组的长度len，并且要遍历字符数组，所以需要设立工作指针temp

void stringAssign(String* s, char* x)
{
	int len = 0;//记录字符数组x的长度
	char* temp = x;//设置工作指针来遍历数组获得长度
	while (*temp)
	{
		len++;
		temp++;
	}
	if (len == 0)//则传入的是空串
	{
		s->data = NULL;
		s->len = 0;
	}
	else
	{
		temp = x;//复位temp
		s->len = len;
		s->data = new char[len];//给串的数据域new一个len长的字符数组
		for (int i = 0; i < len; i++)//将传入的字符数组赋给串
		{
			s->data[i] = *temp;
			temp++;
		}
	}
}

打印字符串

void printString(String* s)
{
	for (int i = 0; i < s->len; i++)
	{
		cout << s->data[i] << " ";
	}
	cout << endl;
}

BF匹配

重点：主串的回溯与子串的回溯

int BF(String* master, String* sub)
{
	int i = 0;//主串索引下标
	int j = 0;//子串索引下标
	while (i < master->len && j < sub->len)
	{
		if (master->data[i] == sub->data[j])//若主串与子串都匹配成功，则同时移动一位
		{
			i++;
			j++;
		}
		else//如果匹配失败
		{
			i = i - j + 1;//主串回溯到初始位置的下一位
			j = 0;//子串回溯到第一个
		}
	}
	if (j == sub->len)//若j==sub->len，则代表子串已经成功匹配玩所有的字符
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

完整的BF算法

#include<iostream>
#include<stdlib.h>
#include<cstring>
using namespace std;
typedef struct String
{
	char* data;//数据域
	int len;//串的长度
}String;
String* initString()//初始化
{
	String* s = new String;
	s->data = NULL;//防止野指针
	s->len = 0;//初始化为0
	return s;
}
void stringAssign(String* s, char* x)
{
	int len = 0;//记录字符数组x的长度
	char* temp = x;//设置工作指针来遍历数组获得长度
	while (*temp)
	{
		len++;
		temp++;
	}
	if (len == 0)//则传入的是空串
	{
		s->data = NULL;
		s->len = 0;
	}
	else
	{
		temp = x;//复位temp
		s->len = len;
		s->data = new char[len];//给串的数据域new一个len长的字符数组
		for (int i = 0; i < len; i++)//将传入的字符数组赋给串
		{
			s->data[i] = *temp;
			temp++;
		}
	}
}
void printString(String* s)
{
	for (int i = 0; i < s->len; i++)
	{
		cout << s->data[i] << " ";
	}
	cout << endl;
}
int BF(String* master, String* sub)
{
	int i = 0;//主串索引下标
	int j = 0;//子串索引下标
	while (i < master->len && j < sub->len)
	{
		if (master->data[i] == sub->data[j])//若主串与子串都匹配成功，则同时移动一位
		{
			i++;
			j++;
		}
		else//如果匹配失败
		{
			i = i - j + 1;//主串回溯到初始位置的下一位
			j = 0;//子串回溯到第一个
		}
	}
	if (j == sub->len)//若j==sub->len，则代表子串已经成功匹配玩所有的字符
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

int main()
{
	String* s1 = initString();
	String* s2 = initString();
	char s11[20], s22[20];
	cin >> s11 >> s22;
	stringAssign(s1, s11);
	stringAssign(s2, s22);
	printString(s1);
	printString(s2);
	cout<<BF(s1, s2);
}

KMP算法

在BF算法上的提升：主串不进行回溯，子串回溯；

子串回溯的位置由next数组来确定 ；next[i]的值表示下标为i的字符前的字符串最长相等前后缀的长度；也表示该处字符不匹配时应该回溯到的字符的下标

next数组是由子串来决定的，了解next数组之前我们先要了解前缀与后缀以及最长相等前后缀

比如：字符串abcdab 

前缀的集合：{a,ab,abc,abcd,abcda}
后缀的集合：{b,ab,dab,cdab,bcdab}
那么最长相等前后缀不就是ab嘛

接下来我们来模拟一下KMP匹配

第一个长条代表主串，第二个长条代表子串

 å¨è¿éæå¥å¾çæè¿°

红色部分代表两串中已匹配的部分，绿色和蓝色部分分别代表主串和子串中不匹配的字符

现在发现了不匹配的地方，根据KMP的思想我们要将子串向后移动，现在解决要移动多少的问题；之前提到的最长相等前后缀的概念有用处了。因为红色部分也会有最长相等前后缀。如下图：

å¨è¿éæå¥å¾çæè¿°

 灰色部分就是红色部分字符串的最长相等前后缀；

我们子串移动的结果就是让子串的红色部分最长相等前缀和主串红色部分最长相等后缀对齐。

å¨è¿éæå¥å¾çæè¿°

这一步弄懂了，KMP算法的精髓就差不多掌握了。接下来的流程就是一个循环过程了。

每一个字符前的字符串都有最长相等前后缀，而且最长相等前后缀的长度是我们移位的关键，所以我们单独用一个next数组存储子串的最长相等前后缀的长度。


所以next[i]=j,含义是：下标为i 的字符前的字符串最长相等前后缀的长度为j。
我们可以算出，子串t= "abcabcmn"的next数组为：

next[0]=-1(前面没有字符串单独处理);

next[1]=0(第二个字符前面只有一个字符，不存在最长相等的前后缀，所以为0)；

next[2]=0(c的前面有ab，前缀为a后缀为b，故没有最长相等前后缀，所以为0)；

next[3]=0(a的前面有abc，前缀有ab后缀有bc，或者前缀有a后缀有c，但是两个都不是相等的，所以没有最长相等的前后缀，所以为0）；

next[4]=1(b的前面有abca，前缀有abc,ab,a后缀有bca,ca,a，发现前后缀有相等的(前缀a=后缀a)，所以最长相等的前后缀长度为1)

next[5]=2(c的前面有abcab，前缀有abca,abc,ab,a后缀有bcab,cab,ab,a，发现前后缀有相等的最大的是(前缀ab=后缀ab)，所以最长相等的前后缀长度为2）

next[6],next[7]同理

abcabcmn
next[0]next[1]next[2]next[3]next[4]next[5]next[6]next[7]
-10001230

获得next数组

int* getNext(String* sub)
{
	int* next = new int[sub->len];//new一个子串那么长的next数组
	int i = 0;//子串的索引下标
	int j = -1;//next数组的索引下标
	next[i] = -1;//next数组的第一个元素单独处理
	while (i < sub->len-1)//因为第一个不用处理，所以i小于len-1就行了
	{
		if (j == -1 || sub->data[i] == sub->data[j])
		{
			//next[0]=-1跳过了
			//next[1]=0,因为第二个字符前面只有一个字符，所以不存在最长相等前后缀的长度
			//next[i]保存了第j个字符的最长相等前后缀的长度
			i++;
			j++;
			next[i] = j;
		}
		else
		{
			j = next[j];//next[j]的值表示下标为j的字符 前的 字符串最长相等前后缀的长度。
						//匹配失败时，next[j]的值就是应该回溯到的字符的下标，并赋值给j
		}
	}
	return next;
}

打印next数组

void printNext(int* next, int len)
{
	cout << "Next数组:";
	for (int i = 0; i < len; i++)
	{
		cout << next[i] << " ";
	}
	cout << endl;
}

KMP匹配

匹配过程类似BF暴力，但是主串不回溯，且子串回溯的值由next数组来确定

int KMP(String* master, String* sub, int* next)
{
	int i = 0;//主串的下标索引
	int j = 0;//子串的下标索引
	while (i < master->len && j < sub->len)
	{
		if (j == -1 || master->data[i] == sub->data[j])
		{
			i++;
			j++;
		}
		else//匹配失败
		{
			j = next[j];//子串进行回溯，回溯到的位置就是此时next[j]的值
		}
	}
	if (j >= sub->len)//如果子串的j匹配完成
	{
		return i - sub->len;//返回子串匹配成功在主串的数组下标
	}
	else
	{
		return -1;
	}
}

完整的KMP匹配

#include<iostream>
using namespace std;
typedef struct String
{
	char* data;//存放串的数据域
	int len;//串的长度
}String;
String* initString()
{
	String* s = new String;
	s->data = NULL;//让data赋初值为NULL
	s->len = 0;//串的长度初始化为0
	return s;
}
void stringAssign(String* s, char* x)
{
	if (s->data)//如果new出来的data不为空，就先delete掉
	{
		delete s->data;
	}
	else//new出来的data为空，可以赋初值x
	{
		int len = 0;//记录传入字符数组的长度
		char* temp = x;//设置工作指针来遍历x字符数组，以求得x的长度
		while (*temp)//只要*temp不为空就循环下去
		{
			len++;
			temp++;//temp移动到下一位
		}
		if (len == 0)//若传入的字符串为空串
		{
			s->data = NULL;
			s->len = 0;
		}
		else
		{
			temp = x;//重新复位工作指针
			s->len = len;//将字符串的长度赋值给主串
			s->data = new char[len + 1];//len+1给主串开辟空间
			for (int i = 0; i < len; i++)//将字符数组赋值给主串
			{
				s->data[i] = *temp;
				temp++;
			}
		}

	}
}
void printString(String* s)
{
	for (int i = 0; i < s->len; i++)
	{
		cout << s->data[i] << " ";
	}
	cout << endl;
}
//next[i]的值表示下标为i的字符前的字符串最长相等前后缀的长度。
//表示该处字符不匹配时应该回溯到的字符的下标
int* getNext(String* sub)
{
	int* next = new int[sub->len];//new一个子串那么长的next数组
	int i = 0;//子串的索引下标
	int j = -1;//next数组的索引下标
	next[i] = -1;//next数组的第一个元素单独处理
	while (i < sub->len-1)//因为第一个不用处理，所以i小于len-1就行了
	{
		if (j == -1 || sub->data[i] == sub->data[j])
		{
			//next[0]=-1跳过了
			//next[1]=0,因为第二个字符前面只有一个字符，所以不存在最长相等前后缀的长度
			//next[i]保存了第j个字符的最长相等前后缀的长度
			i++;
			j++;
			next[i] = j;//
		}
		else
		{
			j = next[j];//next[j]的值表示下标为j的字符 前的 字符串最长相等前后缀的长度。
						//匹配失败时，next[j]的值就是应该回溯到的字符的下标，并赋值给j
		}
	}
	return next;
}
void printNext(int* next, int len)
{
	cout << "Next数组:";
	for (int i = 0; i < len; i++)
	{
		cout << next[i] << " ";
	}
	cout << endl;
}
int KMP(String* master, String* sub, int* next)
{
	int i = 0;//主串的下标索引
	int j = 0;//子串的下标索引
	while (i < master->len && j < sub->len)
	{
		if (j == -1 || master->data[i] == sub->data[j])
		{
			i++;
			j++;
		}
		else//匹配失败
		{
			j = next[j];//子串进行回溯，回溯到的位置就是此时next[j]的值
		}
	}
	if (j >= sub->len)//如果子串的j匹配完成
	{
		return i - sub->len;//返回子串匹配成功在主串的数组下标
	}
	else
	{
		return -1;
	}
}
int main()
{
	String* s1 = initString();
	String* s2 = initString();
	char a[] = "abcabeabcabcmn";
	char b[] = "abcabcmn";
	stringAssign(s1, a);
	stringAssign(s2, b);
	printString(s1);
	printString(s2);
	int* next = getNext(s2);
	printNext(next, s2->len);
	cout <<"子串在主串中的位置(数组下标)："<< KMP(s1, s2, next) << endl;
}

参考链接：https://blog.csdn.net/weixin_46007276/article/details/104372119?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522162419731416780366567151%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=162419731416780366567151&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-104372119.pc_search_result_before_js&utm_term=kmp&spm=1018.2226.3001.4187

薇鹅鹅莉特
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
字符串匹配理解
茶未凉的博客
08-28 261
对于字符串匹配一直是一个热点。 比如一
数据结构（五）——队列实现及其应用
仙八哥的博客
03-11 462
1、顺序队列的原理 队列是限制在两端进行插入操作和删除操作的线性表 允许进行存入操作的一端称为“队尾” 允许进行删除操作的一端称为“队头” 当线性表中没有元素时，称为“空队” 特点：先进先出（FIFO） 双端队列 2、顺序队列的实现 声明结构体 typedef int datatype; #define N 128 typedef struct { datatype data[N]; int front; int rear; }sequeue; 2.1 创建队列 sequeue * q
null和""的区别
liming92973的专栏
11-02 626
null和""的区别 问题一： null和""的区别 String s=null; string.trim()就会抛出为空的exception   Strings="";   string.trim()就不会抛,为什么? 答： NULL代表声明了一个空对象，根本就不是一个字符串。   ""代表声明了一个对象实例，这个对象实例的值是一个长度为0的空字符串。   NULL
串(string)的基本用法
Lzinner的博客
03-22 462
2018/3/22数据结构1.串（string）1.概念：由n个字符所组成的有限数列2.串是一种特殊的线性表，但是也有着不同之处，串的操作对象只能是字符，而且线性表一次只能操作一个数，但是串一次可以操作多个字符2.动态数组的应用注：这里是采用动态数组的方法来分配空间，即：在空间不够的时候，继续动态分配空间（realloc（size，number））#include&lt;malloc.h&gt; ...
串的表示和基本操作
w_nxsxs的博客
11-14 1992
【问题描述】 实现串的顺序表示和基本操作。 【输入形式】 第一行输入一个字符串； 第二行输入一个字符串； 第三行输入两个整数，分别表示在第一个字符串中获取子串的起始位置和长度； 【输出形式】 输出两个字符串比较的结果，若相等输出=，否则输出<> 输出子串（若子串获取不成功，输出error） 输出两个字符串的连接结果 【样例输入1】 123456 abcdefg 3 4 【样例输出1】 <> 3456 123456abcdefg 【样例输入2】 ABC
深入浅出解析字符串匹配算法
09-10
给出了详细的字符串匹配算法的分析实现过程，由浅入深，最后引出其实现的快速算法。易于理解，编码实现非常简洁
浅谈python下含中文字符串正则表达式的编码问题
10-17
今天小编就为大家分享一篇浅谈python下含中文字符串正则表达式的编码问题，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
浅谈python中列表、字符串、字典的常用操作
01-21
删：a.remove(haha) 删除列表中从左往右，第一个匹配到的 haha del a.[0] 删除下标为0 对应的值 a.pop(0) 括号里不写内容，默认删除最后一个，写了，就删除对应下标的内容 改：a.[0] = “gg” 查：a[0] a.index...
浅谈正则速记法的技巧
12-13
给你一篇文章，如何挑选出你想要的字符串呢？你可以从左到右从上到下，一个一个字符读取出来，写一大堆if做判断。这样太麻烦了，正则就是将以上过程抽象出来，用一些特定符号就能表示出大部分规则 对大部分人来说，...
浅谈Linux grep与正则表达式
12-13
egrep为扩展的grep，fgrep则为快速grep（固定的字符串来对文本进行搜索，不支持正则表达式的引用但是查询极为快速）。grep是Linux文本处理三剑客之一。 grep使用方式 　使用方式： grep [OPTIONS] PATTERN [FILE......
NSString几种创建方法
狮子Lion的专栏
09-17 1039
1.init  初始化一个不包含字符串的NSString对象 NSString *initString1 = [[NSString alloc] init]; NSLog(@"initString1 ----------- %@",initString1); [initString1 release]; 2.initWithFormat NSString
<init>()方法
孤落
10-22 5367
()方法，是虚拟机自己调用的，不在我们的程序中显性表示。       那么()的作用是什么？在什么时候被调用？ 实际上，JVM为每一个类的每一个构造方法都创建一个(）方法，用于初始化实例变量。 我们用一个例子来进行分析： public class Test{ private String name; private int age; public Test(){ } pu
算法：字符串
uncle_ll的博客
02-27 872
字符串 字符串简介 字符串：简称为串，是由零个或多个字符组成的有限序列。一般记为s=a1a2...ans=a_1a_2...a_ns=a1​a2​...an​ 字符串名称：字符串定义中的s就是字符串的名称； 字符串的值：a1a2...ana_1a_2...a_na1​a2​...an​组成的字符串就是字符串的值，一般用双引号括起来； 字符变量：字符串每一个位置上的元素都是一个字符变量。字符aia_iai​可以是字母，数字或者其他字符。i是该字符在字符串中的位置； 字符串的长度：字符串中字符的数目n成为字符
`算法知识` 字符串相同前后缀
WChang的博客
07-21 658
1
leetcode刷题（字符串）
qq_40502460的博客
11-04 507
反转字符串 编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。 不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。 示例 1： 输入：s = [“h”,“e”,“l”,“l”,“o”] 输出：[“o”,“l”,“l”,“e”,“h”] 示例 2： 输入：s = [“H”,“a”,“n”,“n”,“a”,“h”] 输出：[“h”,“a”,“n”,“n”,“a”,“H”] # python class Solution:.
[LeetCode]-字符串-1
Pacifica_的博客
03-09 444
记录 LeetCode 刷题时遇到的字符串相关题目，第一篇
第78篇 C++实现字符串匹配（三）KMP算法
weixin_49188222的博客
11-21 5394
第78篇 C++字符串匹配（三）KMP算法1.KMP算法简单描述2.自解next3.原next4.改进next5.KMP代码5.1.原KMP5.2.改进KMP6.所有代码 1.KMP算法简单描述 首先上大佬的链接 数据结构KMP算法配图详解（超详细） 虽然别人写得很好，但是我还是想尝试一下自己能理解多少，所以写一写自己的看法，看看自己能不能把这个算法表述得明白。 KMP算法是一种改进的字符串匹配算法，由D.E.Knuth，J.H.Morris和V.R.Pratt提出的，因此人们称它为克努特—莫里斯—普拉特操
数据结构之B树
嫦娥妹妹等等我的博客
06-16 319
**节点的大小**：每个节点至少有 `t - 1` 个键值（除根节点外），最多有 `2t - 1` 个键值。1. **高效的磁盘读取**：由于每个节点包含多个键值和指针，B树减少了磁盘I/O操作的次数，提高了查找和更新的效率。- **数据库系统**：B树及其变种（如B+树、B*树）广泛用于数据库索引结构，支持快速的数据插入、删除和查询。- 每个节点最多有 `2t - 1` 个键值和 `2t` 个子节点指针，其中 `t` 是B树的最小度数。- **平衡性**：B树是一棵平衡树，所有叶子节点位于同一层。
数据结构：冒泡排序，选择排序，插入排序，希尔排序的实现分析
最新发布
Zhihuiguoz的博客
06-16 674
这篇博客主要介绍了一些基本的排序算法，从算法思想，算法步骤，动图演示，代码实现，复杂度分析，稳定性分析这几个方面详细的介绍了冒泡排序，选择排序，插入排序，希尔排序的运用。并对其进行了优化实现，简单易懂，很好上手。
用C++中的B树进行字符串匹配
04-01
在匹配时，从根节点开始，按照模式字符串的每个字符依次往下搜索，直到找到与模式字符串匹配的节点，然后在该节点的关键字列表中查找是否存在完全匹配的字符串。 具体实现中，可以使用递归或非递归的方式进行搜索。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值