模式匹配算法无效位移是什么

‘壹’ 串模式匹配算法（C语言）100分悬赏

第一个朴素算法:
1.普通的串模式匹配算法:
int index(char s[],char t[],int pos)
/*查找并返回模式串T在S中从POS开始的位置下标,若T不是S的子串.则返回-1.*/
{
int i,j,slen,tlen;
i=pos;j=0; //i,j分别指示主串和模式串的位置.
slen=strlen(s);tlen=strlen(t); //计算主串和模式串的长度.
while(i<slen && j<tlen)
{
if(s[i]==t[j]) {i++;j++;}
else {i=i-j+1;j=0;}
}
if(j>=tlen) return i-tlen;
return -1;
}

第二个KMP算法.该算法支持从主串的任意位置开始搜索.
2.KMP算法:
//求模式串的next函数.
void get_next(char *p,int next[])
{
int i,j,slen;
slen=strlen(p);i=0;
next[0]=-1;j=-1;
while(i<slen)
{
if(j==-1||p[i]==p[j]) {++i;++j;next[i]=j;}
else j=next[j];
}
}

//KMP模式匹配算法
int index_kmp(char *s,char *p,int pos,int next[])
/* 利用模式串P的NEXT函数,求P在主串S中从第POS个字符开始的位置*/
/*若匹配成功.则返回模式串在主串中的位置下标.否则返回-1 */
{
int i,j,slen,plen;
i=pos-1;j=-1;
slen=strlen(s);plen=strlen(p);
while(i<slen && j<plen)
{
if(j==-1||s[i]==p[j]) {++i;++j;}
else j=next[j];

‘贰’ KMP模式匹配算法是什么

KMP模式匹配算法是一种改进算法，是由D.E.Knuth、J.H.Morris和v.R.Pratt提出来的，因此人们称它为“克努特－莫里斯－普拉特操作”，简称KMP算法。此算法可以在O（n＋m）的时间数量级上完成串的模式匹配操作。其改进在于：每当一趟匹配过程出现字符不相等时，主串指针i不用回溯，而是利用已经得到的“部分匹配”结果，将模式串的指针j向右“滑动”尽可能远的一段距离后，继续进行比较。

1.KMP模式匹配算法分析回顾图4－5所示的匹配过程示例，在第三趟匹配中，当i＝7、j＝5字符比较不等时，又从i＝4、j＝1重新开始比较。然而，经仔细观察发现，i＝4和j＝1、i＝5和j＝1以及i＝6和j＝1这三次比较都是不必进行的。因为从第三趟部分匹配的结果就可得出，主串中的第4、5和6个字符必然是b、c和a（即模式串第2、第2和第4个字符）。因为模式中的第一个字符是a，因此它无须再和这三个字符进行比较，而仅需将模式向右滑动2个字符的位置进行i＝7、j＝2时的字符比较即可。同理，在第一趟匹配中出现字符不等时，仅需将模式串向右移动两个字符的位置继续进行i＝2、j＝1时的字符比较。由此，在整个匹配过程中，i指针没有回溯，如图1所示。

图1改进算法的模式匹配过程示意

‘叁’ 串的模式匹配是什么

串的模式匹配即子串定位，是一种重要的串的运算。设S是给定的主串，T是给定的子串，在主串S中查找等于子串T的串的过程称为模式匹配，T称为模式串。如果在S中找到T子串，则称匹配成功，函数返回T在S中首次出现的存储位置（或序号），否则匹配失败，返回0。为了运算方便，假设串采用顺序存储结构，串的长度存放在0号单元，串值从1号单元开始存放，这样字符序号与存储位置一致。

‘肆’ 串的模式匹配算法中的BRUTE FORCE算法在最好情况下的时间复杂度为什么是O(n+m)而不是O(m)其中m是模式...

理解你的意思,你觉得O(m)是第一次搜索就找到推出函数了对吧, 这时候你可以认为是O(m), 但是 当 文本中找不到模式串的时候,比如 bbbbb中找a ,是不需要扫描一下文本bbbbb, 复杂度就是O(n), 说成O(n+m) 没有太大意义

‘伍’ C语言数据结构串的模式匹配算法问题

和while循环里面的一样，i指针退回原来的位置并指向下一位，应该是多少？i-j+2是吧！

这里不用指向下一位，直接return它的位置就行了，于是return i-j+1

i-j+1和i-t[0]相等！

‘陆’ 数据结构关于串的KMP算法的理解高手请进

KMP 算法是一种字符串的模式匹配算法，参看严蔚敏数据结构一书，里面讲的很清楚。
基本的字符串匹配算法是将被匹配的字符串S和模式串T 逐个字符进行比较。例如:S中有10个字符，T中有5个字符。S串初始的匹配位置为3.则从S中的第3个字符与T中的第一个字符匹配，若相同则S的第4个字符与T中的第2个字符匹配。直到匹配成功或者出现失配字符。当出现失配情况下，移动标识S中当前进行比较的字符指针，会退到第4个字符处。然后，重复这一过程。简单说，基本的字符匹配算法是通过移动被匹配的字符串S，进行比较字符的指针位置来完成字符匹配的。
而KMP算法刚好相反，在整个匹配过程中S中当前比较字符的指针并不发生回退现象，当出现S中的字符与T中的字符失配的时候。通过改变T的当前比较字符位置的指针来确定当前S中的字符该与T中哪个字符进行比较。简单说，通过模式字符串T的当前比较字符的指针的回退来完成字符匹配。
当理解了KMP算法通过改变T的当前比较字符位置的指针来完成匹配时，接下来要理清的是模式字符串T中的字符指针在失配的情况下是如何移动的。
以严蔚敏数据结构一书中KMP为例，对于模式字符串T，KMP维护了一个对应于T中每个字符弱发生失配情况下，指针回退到哪一位置的数组。当被匹配串S与模式串T发生失配的情况下，T读取数组中相应记录的位置，讲指针回退。如果回退后仍然失配则S的当前比较字符位置指针+1，T串指针回到第一个字符处。
由此可见获取数组中存储的数据是KMP算法的关键，书中的公式看起来有点抽象。数组中的存储指针的位置是根据，模式串T与自身的匹配过程获取的。
实际上是说，模式串T的第一个字符，如果出现失配则不会回退；当前比较位置的字符向前N-1位的子串恰好与T中从第一个字符起止N-1个字符形成的子串相等，且N小于当前位置，满足这些条件的N的最大值即为T当前位置指针回退的位置，然后迭代此过程，直到T本身匹配或回退到第一个字符位置仍不匹配，则当前位置的对应的回退位置指针指向T中的第一个字符所在位置。

讲的还不是很清楚，主要是对比一下基本的字符匹配算法和KMP的不同。一个是通过移动被匹配字符串比较字符的指针来实现匹配，一个是移动模式字符串的当前比较字符的位置指针来实现匹配。对于匹配串字符回退位置这个计算书中已经很清楚，根据算法单步调试一次自然就理解了。

‘柒’ 数据结构 字符串 模式匹配问题 KMP算法

你的程序本身思路没有错，但错在以下几点：
1.在程序中有字符串S和T，你用S[0]代表字符串的长度，但S是字符串，S[0]是长度吗？
2.在main函数中，你输入的S和T都是用gets(S)或gets(T),那么它们都是以下标0开头的，你应该要进行处理，使它以下标1作为开头（可以这样gets(&S[1]); 然后S[0] = strlen(&S[1]) + '0';在用S[0]作为长度的时候，把它从字符变成数字就行了)。

‘捌’ C++语言中提供有关串的类

第四章：串(包括习题与答案及要点)

本章介绍了串的逻辑结构，存储结构及串上的基本运算，由于在高级语言中已经提供了较全善的串处理功能，因此本章的重点是掌握在串上实现的模式匹配算法。同时这也是本章的难点。但是从全书来讲，这属于较简单的一章内容。

--------------------------------------------------------------------------------

1.串及其运算(领会)(这些内容比较容易理解，不用死记)

串就是字符串，是一种特殊的线性表，它的每个结点仅由一个字符组成。

空串：是指长度为零的串，也就是串中不包含任何字符(结点)。

空白串：指串中包含一个或多个空格字符的串。不同与空串，它的结点就是一个空格字符。

在一个串中任意个连续字符组成的子序列称为该串的子串，包含子串的串就称为主串。子串在主串中的序号就是指子串在主串中首次出现的位置。如A="I love you" B="love",则B在A中的序号为3，注意空格也是字符。

空串是任意串的子串，任意串是他自身的子串?

串分为两种：串常量和串变量。串常量在程序中不能改变，串变量则可以。

关于串的基本运算，基本上在C语言中已经学过，主要有

求串长strlen(char *s)、

串复制strcpy(char *to,char *from)、

串联接strcat(char *to,char *from)、

串比较charcmp(char *s1,char *s2)

和字符定位strchr(char *s, char c)等

这些基本运算通过练习来掌握。

--------------------------------------------------------------------------------

2.串的存储结构(简单应用)

串是特殊的线性表(结点是字符)，所以串的存储结构与线性表的存储结构类似。

串的顺序存储结构简称为顺序串，顺序串又可按存储分配的不同分为静态存储分配的顺序串和动态存储分配的顺序串。

静态的意思可简单地理解为一个确定的存储空间，它的长度是不可变的。如直接使用定长的字符数组来定义一个串。它的优点是涉及串长的操作速度快，因为它的最大长度是不变的。

动态存储分配就是在定义串时不分配存储空间，直到需要使用时按所需串的长度分配存储单元给它，并且在运行中还可以根据需要变化串的长度，这就是动态分配。不过这样的串仍是顺序存储的，也就是说指针指向串的首地址，后面的结点是连续存储的。

串的链式存储就是用单链表的方式存储串值，串的这种链式存储结构简称为链串。链串与单链表的差异只是它的结点数据域为单个字符。这种存储结构方便于串的插入和删除操作，但是空间利用率不高，因为存放每一个字符要"搭配"一个指向下一字符的地址,而地址所占空间是比较大的。为了解决这种"存储密度"过低的状况，可以让一个结点存储多个字符，事实上这是顺序串和链串的综合(折衷)。

--------------------------------------------------------------------------------

本章的重点和难点就是串运算的实现，特别是顺序串上子串定位的运算。

子串定位运算又称串的"模式匹配"或"串匹配"，就是在主串中查找出子串出现的位置，这在应用中非常广泛，比如文本编辑中的"查找和替换"用到的就是子串定位运算的算法。

在串匹配中，将主串称为目标(串)，子串称为模式(串)，我们这样想象，子串就如同一个模板(样本)，用它在目标上对比，从头往后比较，凡是遇到一模一样的那么一段，就算找到一个位置了(我们就说，从这个位置开始的匹配成功)。用很专业的很酷的话说就是"模式在目标中出现"(我想起了警匪片里的对话),如果这个模板对应的目标串中有不一样的字符出现，那么这个位置就匹配失败。

当我们用这个模子依次从目标的头部往后移,移动到的位置就叫位移，如果每次向右移动1格，那么每次的位移就加上1。

每次移动后要看看模板里的字符和目标中相应的字符是否相等，如果都相同，这次位移就叫有效位移(其实就是从这个位置开始的匹配成功)

另外有一个合法位移和不合法位移的概念，就是说，移动一个位置后，如果模板的最后一个字符还没有超出目标串中最后一个字符时，这个位移就是合法位移，如果超出了，那么就没有比较的意义了，这时就是不合法位移。

这是比较容易理解的，串匹配问题就是找出给定模式串P在给定目标串T中首次出现的有效位移或者是全部有效位移。

具体的串匹配算法也不是很难理解，就是用两个循环，外循环用于进行模式的位移，内循环进行模板内每个字符的比较(判断是否有效位移)。关于串匹配的时间复杂度，在最坏的情况下就是目标串和模式串分别是"a^n-1b"和"a^m-1b"的形式，就是说，每一次合法位移后，在内循环中都要比较m个字符才知道是不是有效位移(前面的字符都是一样的)。所以最坏的情况下时间复杂度是O((n-m+1)m),假如m与n同阶的话则它是O(n^2)。

链串上的子串定位运算的不同之处就是位移是结点地址而不是整数。理解一下算法即可。

真正的应用主要还是要掌握串的基本算法并用它们构造出可以解决具体问题的简单算法。

第四章 串 复习要点

本章复习要点是：

串是一种特殊的线性表，它的结点仅由一个字符组成。

空串与空白串的区别：空串是长度为零的串，空白串是指由一个或多个空格组成的串。

串运算的实现中子串定位运算又称串的模式匹配或串匹配。

串匹配中，一般将主串称为目标(串),子串称为模式(串)。

本章可能出的题型多半为选择、填空等。

‘玖’ Java编程实现字符串的模式匹配

传统的字符串模式匹配算法（也就是BF算法）就是对于主串和模式串双双自左向右，一个一个字符比较，如果不匹配，主串和模式串的位置指针都要回溯。这样的算法时间复杂度为O（n＊m），其中n和m分别为串s和串t的长度。

KMP 算法是由Knuth，Morris和Pratt等人共同提出的，所以成为Knuth－Morris－Pratt算法，简称KMP算法。KMP算法是字符串模式匹配中的经典算法。和BF算法相比，KMP算法的不同点是匹配过程中，主串的位置指针不会回溯，这样的结果使得算法时间复杂度只为O（n＋m）。

‘拾’ 数据结构（c++）字符串 模式匹配算法问题，对高手来说只要写一点点

#include <string>
using namespace std;

string s = "zabcdefg";

int index1(const string ss, int pos)
{
if (pos<0 || pos>s.length())
printf("pos²»ºÏ·¨£¡");
int i = pos, j = 0;

while (i < s.length() && j < ss.length()) {
if (s[i]==ss[j]) {
i++;
j++;
} else {
i=i-j+1;
j=0;
}
}

if (j>=ss.length())
return (i-j+1);
else
return -1;
}
void getnext(const string ss, int *next)
{
int i = 0, j = -1;
next[i] = -1;
while (i < ss.length()) {
if (j == -1 || s[i] == ss[j]) {
i++;
j++;
next[i]=j;
} else
j = next[j];
}
}

int index2(const string ss, int pos)
{
int *next = new int[ss.length()];
getnext(ss, next);

int i = pos, j = 0;
while (i < s.length() && j < ss.length()) {
if (j==0 || s[i]==ss[j] ) {
++i;
++j;
} else {
j = next[j];
}
}

if (j >= ss.length())
return i-ss.length()+1;
else
return -1;
}

int main()
{
string ss = "abc";
printf("index1: %d, index2: %d\n", index1(ss, 0), index2(ss, 0));

return 0;
}