Algorithm - 数据结构 - String

模式匹配:

  对于两个串 S1, S2. 问 S1 中是否包含 S2 以及其位置.

 

朴素模式匹配

从 S1, S2 开始.

刚开始, 令 i = 0

匹配 S2[0] 和 S1[0] 如果匹配成功, 则匹配 S2[1] 和 S1[1]

如果匹配失败, 则 S1[i++] 直到匹配完成和匹配失败

时间复杂度是 O(nm)

// 朴素模式匹配
// 输入:
//   text : 主串
//   pattern : 模式串
// 输出:
//   index : 匹配对应的开头位置, 如果无法匹配则返回 -1
int PatternMatching(char* text, char* pattern){
    int index = -1;
    for(int i=0; text[i]!='\0'; i++){
        for(int j=0; ;){
            if(pattern[j]=='\0'){
                return index;
            }
            if(pattern[j] == text[i]){
                if(j==0) index=i;
                i ++;
                j ++;
                continue;
            }
            break;
        }
    }
    return -1;
}

 

// 朴素模式匹配
// 输入:
//   text : 主串
//   pattern : 模式串
// 输出:
//   index : 匹配对应的开头位置, 如果无法匹配则返回 -1
int PatternMatching(char* text, char* pattern){
    int i = 0, j = 0;
    while(i < text.length && j < pattern.length){
        if(text[i] != pattern[j]){
            i ++; j ++;
        }
        else{
            i = i - j + 1;
            j = 0;
        }
    }
    return j == p.length ? i - j : -1;
}

 

 

KMP:

一种利用字符串本身的特性来减少匹配次数的一种方法

基本原理是， 当 S1[i] 和 S2[j] 发生不匹配的情况时, 不回退 i， 而是利用 S2 的性质移动 j 进行继续匹配

 

int[] getNext(char* pattern){
    int next[pattren.length] = {0};
    next[0] = -1;
    int j = 0, k = -1;
    while(j < p.length - 1){
        if(k == -1 || p[j] == p[k]){
            next[++j] = ++k;
        }
        else{
            k = next[k];;
        }
    }
    return next;
}

int KMP(char* text, char* pattern){
    int i = 0, j = 0;
    int * next = getNext(pattern);
    while(i < text.length && j < pattern.length){
        if(j == -1 || t[i] == p[j]){
            i ++; j ++;
        }
        else{
            j = next[j];
        }
    }
    return j == pattern.length ? i - j : -1;
}