题目描述：实现strStr()函数，返回子串第一次出现的位置，未出现则返回-1。如：

Input: haystack = "hello", needle = "ll"
Output: 2
Input: haystack = "aaaaa", needle = "bba"
Output: -1

分析：暴力算法时间复杂度O(m*n)，更高效的可以用KMP、各种文本编辑器的"查找"功能大多采用的Boyer-Mooer、Rabin-Karp算法。

暴力法：即母串与子串一个字符一个字符比对，外层循环对母串遍历haystack.size() - needle.size()遍，即子串第一个字符与母串的第几个字符对齐，内层循环遍历子串各字符，看是否都与母串相应位置字符相同。

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

KMP法：为保证只对母串进行一次遍历，要记录子串的next数组，即当子串的某一位与母串不匹配时应该用子串前面的哪一位来重新对应母串的该字符。主要理解getnext函数。因为主串不回溯，next数组已提前计算，故时间复杂度O(n)。

class Solution {
public:
    int strStr(string haystack, string needle) {
        int m = haystack.size();
        int n = needle.size();
        if (n == 0)
            return 0;
        else if(m == 0)
            return -1;
        
        int next[n];
        getnext(needle, next);
        int i = 0, j = 0;
        while (i < m && j < n)
        {
            if (j == -1 || haystack[i] == needle[j])
            {
                i ++;
                j ++;
            }
            else
            {
                j = next[j];
            }
        }
        if (j == n) return i - n;
        else return -1;
    }
    //获取子串的next数组，只与子串有关。对模式串needle做“自匹配”，即求出模式串前缀与后缀中重复部分，将重复信息保存在next数组中
    void getnext(string &s, int next[])
    {
        int l = s.size();
        int i = 0, j = -1;
        next[i] = -1;
        while (i < l - 1)
        {
            if (j == -1 || s[i] == s[j])
            {
                i ++; j ++;
                next[i] = j;
            }
            else
                j = next[j];
        }
    }
};

Horspool算法简易版Boyer-Mooer算法，只实现了坏字符规则，没用好后缀规则。思路见参考，第一个样例可正确输出2，但在样例"mississippi" "issipi"处超时。最坏情况下时间复杂度O(m*n)

class Solution {
public:
    int strStr(string haystack, string needle) {
        int m = haystack.size();
        int n = needle.size();
        if (n == 0)
            return 0;
        else if(m == 0)
            return -1;
        int i = n - 1, j = n - 1;
        while (j >= 0 && i < m)
        {
            if (haystack[i] == needle[j])
            {
                i --, j --;
            }
            else
            {
                i += dist(needle, haystack[i]);
                j = n - 1;
            }
        }
        if (j < 0) return i + 1;
        return -1;
    }
    
    int dist(string t, char c)
    {
        int l = t.length();
        int i = l - 1;
        if (t[i] == c)
            return l;
        
        i --;
        while (i >= 0)
        {
            if (t[i] == c)
                return l - 1 - i;
            else 
                i --;
        }
        return l;
    }
};

Karp-Rabin算法：这是一种一般情况下线性，最坏情况下O((n-m)*m)的算法。算法的主要思路是设计一种哈希函数，将目标字符串映射成一个值，然后在主串中遍历每个与目标串长度相同的子串，用同样的哈希函数算其值，与目标串的哈希值相比较。相等时还要再比较此子串的每个字符与目标串的每个字符，因为哈希函数可能有冲突。

参考

Boyer-Mooer算法讲解