数据结构与算法（5）字符串（BF算法、KMP算法及KMP算法优化）

目录

一、BF算法（暴力算法）

二、KMP算法

三、KMP算法优化

---

一、BF算法（暴力算法）

一个一个往后匹配，匹配失败继续从母串下一个和头（子串的头）往后继续匹配。

虽然简单，但是需要较多的时间复杂度。

//BF算法（暴力算法）
//查找字符串位置（效率低）
//挨个匹配，不匹配的话进入下一个，继续挨个匹配
//注：字符串的末尾自动补'\0'，用strlen()查找的长度比实际存放数据的长度多一个
#include<stdio.h>
#include<string.h>

#define MAXSIZE 20

//KMP查找位置
int BF(char* str, char* a)
{
	int i = 0, j = 0, flag = 1;
	for (i = 0; i < strlen(str) - 1; i++)
	{
		flag = 1;
		for (j = 0; j < strlen(a) - 1; j++)
		{
			if (str[i + j] != a[j])
			{
				flag = 0;
				break;
			}
		}
		if (flag == 1)
			return i;
	}

	return -1;				//查找失败
}

int main()
{
	int i = 0, next[MAXSIZE] = { 0 };
	char str[MAXSIZE] = { ' ' }, a[MAXSIZE] = { ' ' };

	//---------------------------------------输入母串------------------------------------//
	printf("请输入母串：\n");
	//输入字符串
	while (str[i - 1] != '\n')
	{
		scanf_s("%c", &str[i]);
		i++;
	}

	//---------------------------------------输入子串-------------------------------------//
	i = 0;
	printf("请输入子串：\n");
	//输入字符串
	while (a[i - 1] != '\n')
	{
		scanf_s("%c", &a[i]);
		i++;
	}


	printf("\n需要查找的子串位置：%d", BF(str, a));

	return 0;
}

二、KMP算法

KMP算法是一种查找算法，为了减少时间复杂度，而去掉前缀。

原理：母串还是按顺序向后匹配，子串可以直接跳过上一匹配失败的元素的前缀。因为前面的匹配成功后，母串和子串前面元素是一致的，子串有重复的前后缀，母串自然也会有，且都相同，就不再浪费时间去挨个匹配母串前缀-子串前缀，而是直接跳转到母串后缀-子串前缀，那么自然是匹配的，相当于前面这些直接跳过，然后从上次失败的元素开始往后匹配。（降低了时间复杂度）

next[]数组即存放子串每个字符前缀的数组。（其求法是难点）

//KMP算法查找字符串位置
#include<stdio.h>
#include<string.h>

#define MAXSIZE 20

int begin = 1;

//获取子串的next数组
void get_next(char* a, int* next)
{
	int j = 0, i = 1;				//j:前缀		i:后缀
	next[0] = 0;
	next[1] = 0;
	//获取每一下标的next（前缀）
	do
	{
		if (a[j] == a[i])			//相等时，i和j都往后移动
		{
			next[++i] = ++j;
		}
		else if (j == 0)			//j==0时（上面的没执行，a[i]和a[j]说明不相等），直接把next[i+1]赋值j，并把i向后移
		{
			next[++i] = j;
		}
		else								//回溯到上一级
			j = next[j];
	} while (i < strlen(a) - 1 - 1);
}

//KMP查找位置
int KMP(char* str, char* a, int* next)
{
	int i = 0, j = 0, flag = 1;
	while (i < strlen(str) - 1)
	{
		flag = 1;
		for (j = next[j]; j < strlen(a) - 1; j++)
		{
			if (str[i + j] != a[j])
			{
				flag = 0;
				i += j;
				if (j == 0)		//第一位就不匹配了，直接往后移动
					i++;
				break;
			}
		}
		if (flag == 1)
			return i;			//查找成功
	}

	return -1;					//查找失败
}

int main()
{
	int i = 0, next[MAXSIZE] = { 0 };
	char str[MAXSIZE] = { ' ' }, a[MAXSIZE] = { ' ' };

	//---------------------------------------输入母串------------------------------------//
	printf("请输入母串：\n");
	//输入字符串
	while (str[i - 1] != '\n')
	{
		scanf_s("%c", &str[i]);
		i++;
	}

	//---------------------------------------输入子串-------------------------------------//
	i = 0;
	printf("请输入子串：\n");
	//输入字符串
	while (a[i - 1] != '\n')
	{
		scanf_s("%c", &a[i]);
		i++;
	}

	//获取next数组
	get_next(a, next);
	for (i = 0; i < strlen(a) - 1; i++)
		printf("%d ", next[i]);

	//KMP查找下标
	printf("\n需要查找的子串位置：%d", KMP(str, a, next));

	return 0;
}

三、KMP算法优化

普通KMP算法缺陷：遇到前面元素有重复的情况，由于next[]数组，导致会一个个往前回溯，造成时间上的损耗。

优化KMP算法缺陷补全：遇到重复元素可以直接回溯到头，不会造成太多时间损耗。

把原next[]数组改成了nextval[]数组（原来是回溯到j，现在直接回溯到next[j]，也即回溯到头）

//KMP算法优化
// 普通KMP算法：如果遇到元素重复，仍然会一级一级回溯			(next[]数组)
//	优化KMP算法：直接回溯到头（直接跳过了元素重复情况）		(nextval[]数组)
#include<stdio.h>
#include<string.h>

#define MAXSIZE 100

int count = 0;			//获取计算次数（对比KMP算法和KMP优化算法）


//获取子串的nextval数组（KMP优化）
void get_nextval(char* a, int* nextval)
{
	int j = 0, i = 1;				//j:前缀		i:后缀
	nextval[0] = 0;
	nextval[1] = 0;
	count = 0;
	//获取每一下标的nextval（前缀）
	do
	{
		if (a[j] == a[i])			//相等时，i和j都往后移动
		{
			if (a[j + 1] != a[i + 1])
				nextval[++i] = ++j;
			else
				nextval[++i] = nextval[++j];
		}
		else if (j == 0)			//j==0时（上面的没执行，a[i]和a[j]说明不相等），直接把nextval[i+1]赋值j，并把i向后移
		{
			nextval[++i] = j;
		}
		else								//回溯到上一级
			j = nextval[j];

		count++;
	} while (i < strlen(a) - 1 - 1);
}

//获取子串的next数组
void get_next(char* a, int* next)
{
	int j = 0, i = 1;				//j:前缀		i:后缀
	next[0] = 0;
	next[1] = 0;
	count = 0;
	//获取每一下标的next（前缀）
	do
	{
		if (a[j] == a[i])			//相等时，i和j都往后移动
		{
			next[++i] = ++j;
		}
		else if (j == 0)			//j==0时（上面的没执行，a[i]和a[j]说明不相等），直接把next[i+1]赋值j，并把i向后移
		{
			next[++i] = j;
		}
		else								//回溯到上一级
			j = next[j];

		count++;
	} while (i < strlen(a) - 1 - 1);
}

//KMP查找位置
int KMP(char* str, char* a, int* nextval)
{
	int i = 0, j = 0, flag = 1;
	while (i < strlen(str) - 1)
	{
		flag = 1;
		for (j = nextval[j]; j < strlen(a) - 1; j++)
		{
			if (str[i + j] != a[j])
			{
				flag = 0;
				i += j;
				if (j == 0)		//第一位就不匹配了，直接往后移动
					i++;
				break;
			}
		}
		if (flag == 1)
			return i;			//查找成功
	}

	return -1;					//查找失败
}

int main()
{
	int i = 0, nextval[MAXSIZE] = { 0 };
	char str[MAXSIZE] = { ' ' }, a[MAXSIZE] = { ' ' };
	printf("----------注：请输入长一点的**子串**才能比较出两算法优劣----------\n");

	//---------------------------------------输入母串------------------------------------//
	printf("请输入母串：\n");
	//输入字符串
	while (str[i - 1] != '\n')
	{
		scanf_s("%c", &str[i]);
		i++;
	}

	//---------------------------------------输入子串-------------------------------------//
	i = 0;
	printf("请输入子串：\n");
	//输入字符串
	while (a[i - 1] != '\n')
	{
		scanf_s("%c", &a[i]);
		i++;
	}

	//获取nextval数组并对比KMP算法优劣
	get_nextval(a, nextval);
	printf("KMP优化:%d\n", count);
	get_next(a, nextval);
	printf("KMP    :%d\n", count);

	//KMP查找下标
	printf("\n需要查找的子串位置：%d", KMP(str, a, nextval));

	return 0;
}