KMP算法的过程演示

已于 2022-05-23 11:22:44 修改
阅读量73 收藏
点赞数
文章标签： KMP算法 动态规划 字符串匹配 next数组 模式串
于 2022-05-23 01:32:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dev_xiaobai/article/details/121469081
版权

KMP算法的过程演示

在这里插入图片描述
`

#include <stdio.h>
#include <string.h>
#include <graphics.h>
#include <windows.h>

#define W 1400
#define H 600
#define BIAN 100
#define GZ 30
#define X(i) (BIAN+GZ*(i*2))
#define Y(i) (BIAN+GZ*i)
#define Arow 1
#define Brow 7

//*******************画图功能区************************************
//画指针和名称
void huazhizhen(int i, int color, int row, char* str, int* n) {
	//画指针
	setcolor(color);
	if (row == Brow + 3 || row == Brow - 1 || row == Arow + 3) {   // row = 4  6  10
		line(X(i) + (GZ - 2), Y(row) - GZ / 5, X(i) + (GZ - 2), Y(row) - GZ * 4 / 5);          //上指针
		line(X(i) + (GZ - 2), Y(row) - GZ * 4 / 5, X(i) + (GZ - 2) - 3, Y(row) - GZ / 2);
		line(X(i) + (GZ - 2), Y(row) - GZ * 4 / 5, X(i) + (GZ - 2) + 3, Y(row) - GZ / 2);
		row = row + 2;
	} else {
		line(X(i) + (GZ - 2), Y(row) - GZ / 5, X(i) + (GZ - 2), Y(row) - GZ * 4 / 5);           //下指针
		line(X(i) + (GZ - 2), Y(row) - GZ / 5, X(i) + (GZ - 2) - 3, Y(row) - GZ / 2);
		line(X(i) + (GZ - 2), Y(row) - GZ / 5, X(i) + (GZ - 2) + 3, Y(row) - GZ / 2);
	}
	//合并str 和 n 为 str1
	char ai[5];
	char str1[12];
	strcpy(str1, str);
	if (n != NULL) {
		sprintf(ai, "%d", *n);
		strcat(str1, ai);
	}
	//输出 str1
	xyprintf(X(i) + (GZ - 2 - 3), Y((row - 1)) - GZ * 3 / 5, str1);
	Sleep(200);
}
//输出标注符号
void biaozhu_J(int i, int color, int row, char* str) {
	setcolor(color);
	outtextxy(X(i) - 10 + (GZ - 2 - 3), Y((row + 2)) - GZ * 4 / 5, str);
	Sleep(20);
}
//输出对比后有颜色的字符
void drawCharArray1(char *A, char *B, int row, int ii, int B_go) {
	int AA = strlen(A);
	int B_row = row + 1;	
	char C[AA] = {0};
	//把数组B转成数组C 数组C随着B_go变化下标位置
	for (int i = 0; i < AA; i++) {
		if (B[i]) {				
			C[B_go + i] = B[i];
		}
	}
	//输出数组A和数组C
	if (A[ii] == C[ii] && ii >= B_go) {//A 和 C 相同 且>B_go 就按  绿色  输出字符
		setcolor(GREEN);
		outtextxy(X(ii) + (GZ - 5), Y(row) + GZ / 5, A[ii]);
		outtextxy(X(ii) + (GZ - 5), Y(B_row) + GZ / 5, C[ii]);
	} else if (A[ii] != C[ii] && ii >= B_go && C[ii] != 0) {   //A 和 C 不同 且>B_go C不为空 就按 上绿下红  输出字符
		setcolor(GREEN);
		outtextxy(X(ii) + (GZ - 5), Y(row) + GZ / 5, A[ii]);
		setcolor(RED);
		outtextxy(X(ii) + (GZ - 5), Y(B_row) + GZ / 5, C[ii]);
	}
	Sleep(300);
}
//只画白色的 A[] B[] 字符
void drawCharArray_white(char *A, char *B, int row, char* strA, char* strB, int B_go) {
	int AA = strlen(A);
	int B_row = row + 1;
	//把B[]转成C[]
	char C[AA] = {0};	
	for (int i = 0; i < AA; i++) {
		if (B[i]) {					
			C[B_go + i] = B[i];
		}
	}
	setcolor(WHITE);
	//输出数组名
	outtextxy(X(0) - (GZ - 2), Y(row) + GZ / 5, strA);
	outtextxy(X(0) - (GZ - 2), Y(B_row) + GZ / 5, strB);
	Sleep(20);
	//输出数组内容
	for (int i = 0; i < AA; i++) {
		outtextxy(X(i) + (GZ - 5), Y(row) + GZ / 5, A[i]);
		outtextxy(X(i) + (GZ - 5), Y(B_row) + GZ / 5, C[i]);
		Sleep(20);
	}
}
//黑掉字符，相当于清除字符数组B[]
void drawBlackArray(char *A, int row,int go) {
	int AA = strlen(A);	
	for (int i = 0; i < AA+go; i++) {		
		setcolor(BLACK);		
		outtextxy(X(i) + (GZ - 5), Y(row) + GZ / 5, "██");		
	}
}
//给初始化next[]用
void drawCharArray_Next(char *A, int row, char* str, int ii, int jj) {
	int AA = strlen(A);
	setcolor(WHITE);
	outtextxy(X(0) - (GZ - 2), Y(row) + GZ / 5, str);
	Sleep(30);
	for (int i = 0; i < AA; i++) {
		if (ii == i) {
			setcolor(GREEN);
		} else if (jj == i) {
			setcolor(RED);
		} else {
			setcolor(WHITE);
		}
		outtextxy(X(i) + (GZ - 5), Y(row) + GZ / 5, A[i]);
		Sleep(30);
	}
}

void drawInitNext(int *A, int num, int row) {
	char str_next[] = "next[1]:";
	//  黑掉之前的“next[num]”
	setcolor(BLACK);
	char ai[5];
	strcpy(str_next, "next[");
	sprintf(ai, "%d", num - 1);
	strcat(str_next, ai);
	strcat(str_next, "]:");
	outtextxy(X(0) - (GZ) * 5 / 2, Y(row) + GZ / 5, str_next);
	// 重写“next[num]”
	setcolor(WHITE);
	strcpy(str_next, "next[");
	sprintf(ai, "%d", num);
	strcat(str_next, ai);
	strcat(str_next, "]:");
	outtextxy(X(0) - (GZ) * 5 / 2, Y(row) + GZ / 5, str_next);
	//再写出next[num]的各值
	for (int i = 0; i < num; i++) {
		setcolor(RED);
		xyprintf(X(i) + (GZ - 2), Y(row) + GZ / 5, "%d", A[i]);
	}
	Sleep(20);
}
//***********************************************************************

//调用了普通求next的方式，这里并未直接对next[1]赋值1，但通过函数第一次运行，也可以得出它的值为1
void Next(char* B, int *next) {
	
	char str_B[] = "B:";  // 定义添加字符串 名称字符 B:
	char biaozhu_kuohao[] = "[  ]";
	char biaozhu_dengyu[] = "=   ";
	char B_i_pre[] = "B[i-1]";
	char B_j_pre[] = "B[j-1]";
	char Bi_Bj_Y[] = "B[j-1]==B[i-1]";
	char Bi_Bj_N[] = "B[j-1]!=B[i-1]";
	char next_j[] = "4:j= next[j]";
	char str_next_1[] = "3:next[]=";
	char str_i_1[] = "1:i++";
	char str_j_1[] = "2:j++";
	char str_i[] = "i= ";
	char str_j[] = "j= ";
	// 画字符数组B[]
	next[1] = 0;
	int i = 1;
	int j = 0;
	int B_len = strlen(B);
	drawCharArray_Next(B, Brow, str_B, i, j);

	while (i < B_len) {
		//------------------画图标记---------------------
		drawInitNext(next + 1, i, Brow + 1);	// 画next[] 数组
		if (j == 0) {
			huazhizhen(j, YELLOW, Brow, str_j, &j);  //"j=0"
			huazhizhen(j, BLACK, Brow, str_j, &j);
			huazhizhen(i, YELLOW, Brow, str_i, &i);  //“i=1”
			huazhizhen(i, BLACK, Brow, str_i, &i);
		} else {
			huazhizhen(i - 1, YELLOW, Brow, B_i_pre, NULL);
			biaozhu_J(i - 1, YELLOW, Brow - 1, biaozhu_kuohao);
			huazhizhen(j - 1, YELLOW, Brow, B_j_pre, NULL);
			biaozhu_J(j - 1, YELLOW, Brow - 1, biaozhu_kuohao);
			huazhizhen(j - 1, BLACK, Brow, B_j_pre, NULL);
			huazhizhen(i - 1, BLACK, Brow, B_i_pre, NULL);
		}
		//-----------------------------------------------------------
		int pre_i=i;
		int pre_j=j;
		if (j == 0 || B[i - 1] == B[j - 1]) {
			//------------------画图标记---------------------
			if (B[i - 1] == B[j - 1]) {
				huazhizhen(j - 1, RED, Brow, Bi_Bj_Y, NULL);
				huazhizhen(j - 1, BLACK, Brow, Bi_Bj_Y, NULL);
				Sleep(30);
			}
			//------------------------------------------------

			i++;
			j++;

			//------------------画图标记---------------------			
			huazhizhen(i, RED, Brow, str_i_1, NULL);			
			huazhizhen(j, RED, Brow, str_j_1, NULL);
			drawCharArray_Next(B, Brow, str_B, i, j);
			//------------------------------------------------

			next[i] = j;

			//------------------画图标记---------------------
			huazhizhen(i - 1, RED, Brow + 3, str_next_1, &j);
			huazhizhen(j, BLACK, Brow, str_j_1, NULL);
			huazhizhen(j, YELLOW, Brow, str_j, &j);  //"j=0"
			drawInitNext(next + 1, i, Brow + 1);
			huazhizhen(j, BLACK, Brow, str_j, &j);
			huazhizhen(i - 1, BLACK, Brow + 3, str_next_1, &j);
			huazhizhen(i, BLACK, Brow, str_i_1, NULL);
			//--------------------------------------------------
		} else {
			//------------------画图标记---------------------
			huazhizhen(j - 1, RED, Brow, Bi_Bj_N, NULL);
			huazhizhen(j - 1, BLACK, Brow, Bi_Bj_N, NULL);
			huazhizhen(j, YELLOW, Brow, next_j, NULL);
			biaozhu_J(next[j], YELLOW, Brow, biaozhu_dengyu);
			huazhizhen(j, BLACK, Brow, next_j, NULL);
			int a = j;
			//-------------------------------------------------

			j = next[j];

			//------------------画图标记---------------------
			huazhizhen(j, YELLOW, Brow, str_j, &j);
			drawCharArray_Next(B, Brow, str_B, i, j);
			biaozhu_J(next[a], BLACK, Brow, biaozhu_dengyu);
			huazhizhen(j, BLACK, Brow, str_j, &j);
			//------------------------------------------------
		}
		biaozhu_J(pre_i - 1, BLACK, Brow - 1, biaozhu_kuohao);
		biaozhu_J(pre_j - 1, BLACK, Brow - 1, biaozhu_kuohao);
	}
}
//KMP 的算法
int KMP(char* A, char* B) {
	
	char str_A[] = "A:";
	char str_B[] = "B:";
	char str_i[] = "i";
	char str_j[] = "j";
	drawCharArray_white(A, B, Arow, str_A, str_B, 0);
	Sleep(200);
	
	int next[10];
	Next(B, next); //根据模式串B，初始化next数组
	int i = 1;
	int j = 1;
	int AA = strlen(A);
	int BB = strlen(B);
	
	int pre_j = 1;
	int go_j = 0;
	
	while (i <= AA && j <= BB) {
		//j==0:代表模式串的第一个字符就和当前测试的字符不相等；
		//S[i-1]==T[j-1];如果对应位置的字符相等，两种情况下，指向当前测试的两个指针下标i和j都向后移
		if (j == 0 || A[i - 1] == B[j - 1]) {
			
			huazhizhen(i - 1, YELLOW, Arow, str_i, NULL);
			huazhizhen(j+go_j-1, RED, Arow + 3, str_j, NULL);
			drawCharArray1(A, B, Arow, i - 1, go_j);
			Sleep(20);
			huazhizhen(i - 1, BLACK, Arow, str_i, NULL);
			huazhizhen(j+go_j-1, BLACK, Arow + 3, str_j, NULL);	
			
			i++;
			j++;
			
			pre_j = j;
		} else {
			
			j = next[j]; //如果测试的两个字符不相等，i不动，j变为当前测试字符串的next值
			
			huazhizhen(i - 1, YELLOW, Arow, str_i, NULL);
			huazhizhen(pre_j +go_j-1, RED, Arow + 3, str_j, NULL);			
			drawCharArray1(A, B, Arow, i - 1, go_j);
			Sleep(20);
			go_j = go_j + (pre_j - j);			
			drawBlackArray(B,Arow+1,go_j);
			drawCharArray_white(A, B, Arow,str_A, str_B, go_j);
			Sleep(20);
			huazhizhen(i - 1, BLACK, Arow, str_i, NULL);
			huazhizhen(j + go_j - 1, BLACK, Arow + 3, str_j, NULL);
			pre_j = j;
		}		
		Sleep(500);
	}
	if (j > BB) { //如果条件为真，说明匹配成功
		return i - BB;
	}
	return -1;
}

int main() {

	char A[21] = "ABCABABCDABABDABABCA";
	char B[21] = "ABABCA";

//	init_console();
	initgraph(W, H);  //开窗口
	setbkmode(TRANSPARENT);
	setbkcolor(BLACK);

	int i = KMP(A, B);
	printf("%d\n", i);
	
  	getchar();
	closegraph();

	return 0;
}
谦爸
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
kmp算法实现思路及其代码演示
qq_45637283的博客
05-06 734
一、什么是kmp算法？ 去百度上搜素一下，你会得到下面一段话： KMP算法是一种改进的字符串匹配算法，由D.E.Knuth，J.H.Morris和V.R.Pratt提出的，因此人们称它为克努特—莫里斯—普拉特操作（简称KMP算法）。KMP算法的核心是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。具体实现就是通过一个next()函数实现，函数本身包含了模式串的局部匹配信...
kmp 算法演示
博主回家睡觉了。。。
08-05 639
额。。。。按着程序走了一遍
KMP算法图文演示+详细解读
qq_45162113的博客
04-14 1104
KMP算法介绍 KMP算法俗称“看毛片算法”，是一个解决模式串是否在文本中出现过，若出现则返回其最早出现位置的经典算法。简单 的说就是字符串查找算法。 先看一个案例： 有一个字符串str1=“ABAACABABCAC”,和一个字串str2=“ABABC”; 现在需要判断str1是否包含str2，如果包含则返回第一次出现的角标，否则返回-1 对于这个案例大家最容易想到的就是用暴力匹配来判断，先演...
KMP算法详解+动图演示
M的博客
01-13 2362
KMP算法详解+动图演示
图解kmp算法
前端学习博客
08-15 1617
但是对于kmp算法，如果遇到了不同字符，其实此次你已经知道了前面比较过的字符是什么，那么就设法利用这个已知信息，不要把"搜索位置"移回已经比较过的位置(注意，这里的比较过的位置指的是文本串中已经进行比较过的位置)，继续把它向后移，这样就提高了效率。可以看到，当比较到 f 时，比较错误，然后找到指针左边(不包括该指针)的最长公共前后缀的长度为2，那么指针就移动到下标为2的地方继续向后比较，这个过程就相当于将前缀的位置移动到后缀上。)，从next数组中可以发现，f 左边的长度为2，所以要移动到下标为2的地方。.
KMP算法的改进思路
weixin_45966548的博客
01-22 1894
个人算法学习
KMP算法实现详解
Hellovie's Blog
04-09 900
KMP算法（Knuth-Morris-Pratt算法）是一个著名的字符串匹配算法。该算法相对于Brute-Force（暴力）算法有比较大的改进，主要是消除了主串指针的回溯，从而使算法效率有了某种程度的提高。
KMP算法详解
热门推荐
qq_52905520的博客
07-29 1万+
kmp算法详解
BF算法和KMP算法
weixin_67807492的博客
10-29 1069
即暴力(BruteForce)算法，是普通的模式匹配算法，BF算法的思想就是将目标串S的第一个字符与模式串T的第一个字符进行匹配，若相等，则继续比较S的第二个字符和T的第二个字符；我们发现，第三个并不匹配，所以需要回溯，那么我们就需要用到第三个指针，回到从第一个开始匹配的指针的位置。KMP算法由D.E.Knuth，J.H.Morris和V.R.Pratt三位大神在1977年提出，它的核心算法是利用匹配失败后的信息，减少模式串与主串的匹配次数，以达到快速匹配的目的。如果在接下来遇到的字符串不同，则需要回溯。
kmp基本算法演示.rar
04-05
在这里，我们将结合易语言，详细探讨KMP算法的实现过程。 首先，我们需要构建部分匹配表。这个表记录了每一个前缀和后缀的最大公共长度，用于指导子串在不匹配时的位移。例如，对于子串"ababc"，部分匹配表为[0, 0,...
kmp算法演示
11-20
kmp算法求Next值演示，可以自己多研究一下，上面详细的讲解了KMP算法求Next值的具体方法
kmp算法flsah演示
07-10
kmp算法flsah演示
KMP算法Flash演示
01-29
数据结构中KMP算法过程的Flash演示
易语言kmp基本算法演示
07-21
这个压缩包包含了易语言实现的KMP基本算法的演示源码，对于学习和理解KMP算法以及易语言编程都有很大的帮助。 KMP算法的核心在于避免了对已匹配部分的重复比较，通过构建一个next数组来指导匹配过程。next数组记录...
【C语言知识-输出空格】C语言中输出空格的方法
qq_64108165的博客
08-05 495
【C语言知识-输出空格】C语言中输出空格的方法
图数据库框架及其支持的开发语言和应用场景
极客栈
08-12 186
这些图数据库框架通过提供多种编程语言的支持，使得开发者能够灵活选择适合自己项目的语言进行开发。同时，社区和第三方开发者也会提供各种语言的库和工具，进一步丰富了图数据库的开发生态。
2024年中国汽车行业AI大模型
最新发布
08-12
一、大模型概述 二、中国大模型发展挑战 三、大模型测评 测评平台：方法论、评估维度 IDC 测试：基础能力、应用能力 通用大模型：Qwen-Max-0428 等 四、2024 年大模型发展趋势 技术方向：模型整合、参数规模扩展、多模态融合、小型化 产业方向：国产 AI 芯片、数据产权标准、套壳微调、人工智能伦理 五、大模型知识密度 知识密度提升：MMLU 榜单表现 小参数模型：MiniCPM-Llama3-V 2.5 六、大模型产业应用案例 百度文心一言：发展历程、技术架构、应用场景 华为盘古大模型：CloudMatrix 架构、ModelArts AI 开发生产线 科大讯飞星火大模型：语音交互、智能座舱、机器人超脑 商汤日日新大模型：SenseChat V5、SenseNova 5.0、车载端侧部署 腾讯混元大模型：研发历程、技术优势、行业应用 特斯拉 FSD：端到端自动驾驶、数据驱动 小鹏汽车 XGPT：自动驾驶大模型、AI 天玑系统 毫末智行 DriveGPT：雪湖·海若、多模态感知、语义感知 思必驰 DFM-2：统一生成式对话基础模型、DUI 2.0 面壁智能 MiniCPM
ISTQB(专家级-改进测试过程-实施测试过程改进)考试大纲_模拟题&答案.zip
08-12
ISTQB(专家级-改进测试过程-实施测试过程改进)考试大纲_模拟题&答案
使用EGE图形库进行kmp算法演示
12-15
int kmp(char *s, char *p, int *next) { int i = 0, j = 0; while (i (s) && j (p)) { if (j == -1 || s[i] == p[j]) { i++; j++; } else { j = next[j]; } } if (j == strlen(p)) { return i - j; } ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值