数据结构考研学习-第四章串2-KMP算法求next\nextVal值问题

本节主要展示KMP算法下next数组，nextVal数组的求值

磨砺的不止锋芒，还有灵魂
一个人可以被毁灭，但绝不可以被打败

字符串匹配问题

字符串匹配问题中求这两值的问题比较常见，理解也有一定困难，在此记录！
关键点:KMP算法仅仅关注匹配串本身,其自身规律

1. next算法

sstring 是我的字符串结构体别名，clength是长度

void get_next(sstring T,int next[]){
    int i =1,j =0;
    next[1]  = 0;
    while(i<T.clength){
        if(j==0 || T.ch[i] == T.ch[j]){
            ++i;++j
            next[i] = j;
        }
        else
            j = next[j];
    }
}

2. nextVal算法

sstring 是我的字符串结构体别名，clength是长度

void get_nextVal(sstring T,int nextVal[]){
    int i =1,j =0;
    nextVal[1]  = 0;
    while(i<T.clength){
        if(j==0 || T.ch[i] == T.ch[j]){
            ++i;++j
            if(T.ch[i] != T.ch[j])  nextVal[i] = j;
            else nextVal[i] = nextVal[j];
        }
        else
            j = next[j];
    }
}

3.index_KMP算法

有了next和nextVal函数只需在上一节的index中引用即可，参考上一篇博文

4. 对于给定串求next和nextVal的值

T = a b a b a a a b a b a a

分析:

1. 0位,规定都为0

2. next: 本位值b!=a（上一位值）,需要从第一位开始比较，next[2]=1，
   
   nextVal:next【2】 a！=b,next数组值不等于本位值，使其等于这个next,
   nextVal[2] = next[2] = 1,

3. next: 本位值a!=b（上一位值）,需要从第一位开始比较，next[3]=1，
   
   nextVal: next【3】a =a,next数组值等于本位值，使其等于相等位置的nextVal,
   nextVal[3] = nextVal[next[1]] = nextVal[1] = 0,

4. next: 本位值b!=a（上一位值）,但是本位值等于第2位值，前面匹配，则只需要从第2位开始比较，next[4]=2，
   
   nextVal:next【4】 b=b,next数组值等于本位值，使其等于相等位置的nextVal,
   nextVal[4] = nextVal[2] = 1,

5. next: 本位值a!=b（上一位值）,但是本位值等于第3位值，前面匹配，则只需要从第3位开始比较，next[5]=3，
   
   nextVal:next【5】 a=a,next数组值等于本位值，使其等于相等位置的nextVal,
   nextVal[5] = nextVal[3] = 0,

   ---

6. next: 本位值a=a（上一位值）,前面匹配，根据字串自身规律需要从第4位开始比较，next[6]=4，
   
   nextVal:next【2】 b！=a,next数组值不等于本位值，使其等于这个next,
   nextVal[6] = next[6] = 4

7. next: 本位值a=a（上一位值）,前面匹配，根据字串自身规律需要从第4位开始比较，next[7]=4，
   
   nextVal:next【2】 b！=a,next数组值不等于本位值，使其等于这个next,
   nextVal[7] = next[7] = 4

   ---

8. next: 本位值b!=a（上一位值）,已经出现新规律，但是本位值等于第2位值，根据字串自身规律，则只需要从第2位开始比较，next[8]=2，
   
   nextVal:next【8】 b=b,next数组值等于本位值，使其等于相等位置的nextVal,
   nextVal[8] = nextVal[2] = 1
   …
   后面一样就不赘述了!

---

【总结】

next数组对匹配串T的规律依赖性很强；nextVal需要通过比较next的值与本位值的结果。进而给出结果

	2021，冲冲冲！