【LeetCode】字符串匹配

給定目標串 haystack 和模式串 needle ，返回 needle 在 haystack 中第一次出現的位置下標，若 needle 不是 haystack 的子串則返回 -1。

1. Brute-Force Algorithm（暴力算法 / 簡單模式匹配）

    我自己寫了一種雙層循環的

int strStr(string haystack, string needle) {
    if (needle.empty()) return 0;
    int m = haystack.size(), n = needle.size();
    for (int i = 0; i <= m - n; i++) {
        for (int j = 0; j < n; j++) {
            if (needle[j] != haystack[i + j])
                break;
            if (j == n - 1)
                return i;
        }
    }
    return -1;
}

    看了答案發現了一種更高效的方法，雖然時間復雜度同樣是 O(m*n)，但只要一層循環，非常Nice！

int strStr(string haystack, string needle) {
    if (needle.empty()) return 0;
    int i = 0, j = 0;
    int m = haystack.size(), n = needle.size();
    while (i < m && j < n) {
        if (haystack[i] == needle[j]) {
            i++;
            j++;
        } else {
            i = i - j + 1;
            j = 0;
        }
        if (j == n)
            return i - j;
    }
    return -1;
}

 

2.  KMP算法

算法講解可以參考 http://www.61mon.com/index.php/archives/183/ ，講解的已經很好了。

KMP的時間復雜度僅為 O(m+n)，因為當出現子串與主串某處不匹配時，並不會將遍歷主串的下標 i 回溯，而是利用得到的 next 數組將模式子串向右“滑動”盡可能遠的一段距離，繼續進行比較，提高了效率。

next 數組的求解是關鍵，它是基於模式子串的最長前后綴，next[i] = needle[0] 到 needle[i - 1] 的字符串的最長相同前后綴的長度。

void getNext(string needle, vector<int> &next) {
    int i = 0, j = -1;
    // j 表示最長相同前后綴的長度
    next[0] = j;
    while (i < needle.size()) {
        // j == -1 為邊界條件判斷， j = next[j] 可能使 j 退回到 -1
        if (j == -1 || needle[i] == needle[j]) {
            i++;
            j++;
            next[i] = j;
        } else {
            j = next[j];
        }
    }
}
    
int strStr(string haystack, string needle) {
    if (needle.empty()) return 0;
    int i = 0, j = 0;
    int m = haystack.size(), n = needle.size();
    vector<int> next(n + 1);
    getNext(needle, next);
    while (i < m && j < n) {
        if (j == -1 || haystack[i] == needle[j]) {
            i++;
            j++;
        } else {
            j = next[j];
        }
        if (j == n)
            return i - j;
    }
    return -1;
}

     改進的KMP算法

void getNextval(string needle, vector<int> &nextval) {
    int i = 0, j = -1;
    nextval[0] = j;
    while (i < needle.size()) {
        if (j == -1 || needle[i] == needle[j]) {
            i++;
            j++;
            // 生成 nextval 數組
            if (needle[i] != needle[j])
                nextval[i] = j;
            else
                nextval[i] = nextval[j];
        } else {
            j = nextval[j];
        }
    }
}
    
int strStr(string haystack, string needle) {
    if (needle.empty()) return 0;
    int i = 0, j = 0;
    int m = haystack.size(), n = needle.size();
    vector<int> nextval(n + 1);
    getNextval(needle, nextval);
    while (i < m && j < n) {
        if (j == -1 || haystack[i] == needle[j]) {
            i++;
            j++;
        } else {
            j = nextval[j];
        }
        if (j == n)
            return i - j;
    }
    return -1;
}