字符串匹配-＞暴力匹配+kmp算法匹配(C语言实现)

最新推荐文章于 2025-04-07 15:10:41 发布

yyooYOYO

最新推荐文章于 2025-04-07 15:10:41 发布

阅读量873

点赞数

文章标签：算法 c语言

本文链接：https://blog.youkuaiyun.com/yoyoyoyoy6/article/details/127341193

版权

1.暴力匹配

核心：让指向被查找的字符串的指针不断回溯，直到查找完毕

实现：

//1.初始化字串
//2，暴力匹配
#include<stdio.h>
#include<stdlib.h>

typedef struct String
{
	char* data;  //数据域
	int len;   //存放字符串长度
}String;

//创建一个字符串or 初始化字符串
String* initString()
{
	String* s = (String*)malloc(sizeof(String));
	s->data = NULL;
	s->len = 0;
	return s;
}


//在初始化后的字符串中插入元素
//步骤1.计算字符串长度
//2.让动态创建的字符串存储输入的字符串
void stringAssign(String* s, char* data)
{
	//如果有s->data中有内容，就free掉，防止产生野指针
	if (s->data) 
	{
		free(s);
	}
	int len = 0;
	char* tmp = data;
	//计算字符串长度len
	while (*tmp)
	{
		len++;
		tmp++;
	}
	if (len == 0) {
		s->data = NULL;
		s->len = 0;
	}
	else {
		tmp = data;
		s->len = len;
		// 字符串中有'\0'，所以开辟s->data空间时len(计算len时无包含'\0')要加上1
		s->data = (char*)malloc(sizeof(char) * (len + 1));
		for (int i = 0; i < len; i++ , tmp++)
		{
			s->data[i] = *tmp;
		}
	}
}

//暴力匹配
//步骤1.定义两个变量，作为被查找字符串和要查找的字符串中元素的指针
//2.如果要查找的字符串中的元素和被查找字符串中的元素相等，那就将俩个指针自增1，
//     如果不相等，则让被查找字符串从前一次开始遍历的元素的下一个元素开始向下查找，
//        要查找的字符串则从头开始查找
//3.如果指向要查找的字符串的指针等于要查找的字符串的长度，
//    那么就说明要查找的字符串为被查找字符串的子串
void forceMatch(String* master, String* sub)
{
	int i = 0;
	int j = 0;
	//
	while (i < master->len && j < sub->len) {
		//如果master->data[i] == sub->data[j]时，说明匹配上了，就让i，j都++.继续向下查找
		if (master->data[i] == sub->data[j]) {
			i++; 
			j++;
		}
		//else 从头开始再次遍历
		else {
			i = i - j + 1;
			j = 0;
		}
	}
	//j与sub->len相等时，说明子串已经遍历完了，查找介绍
	if (j == sub->len) {
		printf("ok\n");
	}
	else {
		printf("no\n");
	}
}

void printSting(String* s)
{
	for (int i = 0; i < s->len; i++)
	{
		printf(i == 0 ? " %c " : "-> %c", s->data[i]);
	}
	printf("\n");
}

int main(int argc, char* argv[])
{
	String* a = initString();
	String* b = initString();
	stringAssign(a, "hello");
	printSting(a);
	stringAssign(b, "llo");
	printSting(b);
	forceMatch(a, b);
	
	return 0;
}

暴力匹配
步骤

1.定义两个变量，作为被查找字符串和要查找的字符串中元素的指针
2.如果要查找的字符串中的元素和被查找字符串中的元素相等，那就将俩个指针自增1，
如果不相等，则让被查找字符串从前一次开始遍历的元素的下一个元素开始向下查找，
要查找的字符串则从头开始查找
3.如果指向要查找的字符串的指针等于要查找的字符串的长度，
那么就说明要查找的字符串为被查找字符串的子串

2.kmp算法实现

核心：next数组的实现

实现：

#include<stdio.h>
#include<stdlib.h>
typedef struct String
{
	char* data;  //数据域
	int len;	//存放字符串的长度
}String;

//初始化字符串
String* initString()
{
	String* s = (String*)malloc(sizeof(String));
	s->data = NULL;
	s->len = 0;
	return s;
}

//初始化的字符串中插入字符串
void stringAssing(String* s, char* data) {
	if (s->data) {
		free(s);
	}
	int len = 0;
	char* temp = data;
	while (*temp)
	{
		len++;
		temp++;
	}
	if (len == 0) {
		s->data = NULL;
		s->len = 0;
	}
	else {
		temp = data;
		
		s->len = len;
		s->data = (char*)malloc(sizeof(char) + (len + 1));
		for (int i = 0; i < len; i++, temp++)
		{
			s->data[i] = *temp;
		}
	}
}
//实现next数组
// 实现原理：定义next[1] = 0; next数组的值由 匹配的最长前后缀+1 决定    到某个元素，就拿该元素前面的元素去找匹配的最长前后缀
//   如 a b c a b c  next[1] == 0;  next[2] == a不能和自己匹配=0 + 1 == 1  
//			 next[3] == 1  next[4] == 1  next[5] == 2  
//            next[6] ==前面有ab前后缀相同 + 1 ==  3
//步骤1.创建两个变量作为指向要查找字符串和被查找字符串的查找定位
//2.算出next数组元素的值
// 通过例子解释代码
// 假设有一个字符串：s1 s2 s3 s4 s5 s6 s7 s8 s9 s10
// 状态1:假设s8的next数组的值为4，那么前缀的s1 s2 s3 就与后缀的 s5 s6 s7相配对，如果s4能继续与s8配对，则s9的next的值为5
// 状态2:承接上述的条件，但s4不能继续与s8配对，且s4的next数值为2，所以s1与s3配对，
//	又因为s1 s2 s3 与 s5 s6 s7相配对,所以s5与s7相配对，综上，可得s1 == s3 == s5 == s7
//		所以s7与s1配对，所以只要s2能与s8配对，s9的数值就为3
//   i就代表在要计算的元素的前一个元素，j代表细分的元素
// 在next数组中，i的数值是始终递增的
// next[++i] = ++j; 就代表上面s2与s8配对后，将s9的数值确定
//3.返回next数组
int* getNext(String* s) {
	
	
	int* next = (String*)malloc(sizeof(String) * s->len);
	if (next != NULL)
	{
		free(next);
	}
	int i = 1;
	int j = 0;
	next[i] = j;
	while (i <= s->len) {
		//
		if (j == 0 || s->data[i] == s->data[j]) {
			next[++i] = ++j;
		}
		else {
			j = next[j];
		}
	}
	return next;
}


//实现kmp算法的查找
//核心：j = next[j]; 让查找的串跳过next[j]个元素，再次与被查找的串配对
void kmpMatch(String* master, String* sub, int* next) {
	int i = 0;
	int j = 0;
	while (i < master->len && j < sub->len)
	{
		if (master->data[i] == sub->data[j]) {
			i++;
			j++;
		}
		else if (master->data[0] != sub->data[0])
		{
			i++;
		}
		else {
			//要跳多少个位
			j = next[j];
		}
	}
	if (j == sub->len) {
		printf("in\n");
	}
	else {
		printf("no\n");
	}
}

void printNext(int* next, int len) {
	for (int i = 1; i <= len; i++) {
		printf(i == 1 ? "%d" : "->%d", next[i]);
	}
	printf("\n");
}

void printString(String* s)
{
	for (int i = 0; i < s->len; i++)
	{
		printf(i == 0 ? "%c" : "->%c", s->data[i]);
	}
	printf("\n");
}



int main()
{
	String* a = initString();
	String* b = initString();
	stringAssing(a, "abcabc");
	stringAssing(b, "cab");
	printString(a);
	int* next = getNext(a);
	int* next1 = getNext(b);
	printNext(next1, b->len);
	printNext(next, a->len);
	kmpMatch(a, b, next1);
	
	return 0;
}

实现next数组
①实现原理：定义next[1] = 0; next数组的值由匹配的最长前后缀+1 决定到某个元素，就拿该元素前面的元素去找匹配的最长前后缀
如 a b c a b c next[1] == 0; next[2] == a不能和自己匹配=0 + 1 == 1
next[3] == 1 next[4] == 1 next[5] == 2
next[6] ==前面有ab前后缀相同 + 1 == 3
②步骤

1.创建两个变量作为指向要查找字符串和被查找字符串的查找定位
2.算出next数组元素的值
通过例子解释代码
假设有一个字符串：s1 s2 s3 s4 s5 s6 s7 s8 s9 s10
状态1:假设s8的next数组的值为4，那么前缀的s1 s2 s3 就与后缀的 s5 s6 s7相配对，如果s4能继续与s8配对，则s9的next的值为5
状态2:承接上述的条件，但s4不能继续与s8配对，且s4的next数值为2，所以s1与s3配对，
又因为s1 s2 s3 与 s5 s6 s7相配对,所以s5与s7相配对，综上，可得s1 == s3 == s5 == s7
所以s7与s1配对，所以只要s2能与s8配对，s9的数值就为3
i就代表在要计算的元素的前一个元素，j代表细分的元素
在next数组中，i的数值是始终递增的
next[++i] = ++j; 就代表上面s2与s8配对后，将s9的数值确定
3.返回next数组