LeetCode | Implement strStr()

Implement strStr().

Returns a pointer to the first occurrence of needle in haystack, or null if needle is not part of haystack.

题目解析：

题目是让找到一个串在另一个串中第一次出现的位置。

方案一：暴力求解

可以利用暴力求解，一个一个比较，不匹配了就返回继续比较，时间复杂度高。

char *strStr(char *haystack, char *needle)
	{
		if (!haystack || !needle) return nullptr;
		int n = strlen(haystack);
		int m = strlen(needle);
		for (int i = 0; i <= n - m; i++)
		{
			int j = 0;
			for (; j < m; j++)
			{
				if (needle[j] != haystack[j+i]) break;
			}
			if (j == m) return haystack + i;
		}
		return nullptr;
	}

方案二：KMP算法

有个经典的算法就是KMP，主串的指针不向回走，变动模式串的指针。

KMP中设计到前缀串和后缀串匹配的问题，也就是：

然后NEXT数组就是在这个基础上整体向后移动一位。

首先解释一下为什么要找最大前缀后缀长度？

为了让子串移动最少的个数，我们找到了最长的前缀后缀串，也就表明，这些都是相等的，比如，ABCDAB中最后一个字符和开始的两个字符是相等的。

那为什么要向后移动一位呢？

考虑一下，如果主串的i位置的字符和模式串的最后一个D不相等了，要移动多少个？由于前面的ABCDAB已经相等，那么i-1和i-2已经相等，代表我将模式串的j指向c也就是3即可。正好由于数组是从0开始的，所以D下面的2，也就是B已经求得的多少个最大前后缀相等长度。

有了这个解释，那么如何写代码呢？

从上面的判断，也就是求位置为i的next[i]，我们求i-1的最大前后缀子串。我们把模式串同时当成主串和模式串来求解。当求D的next的时候，通过i-1看到B要和str[1]相比较，如果相等，就是index+1。如果不等，就继续找到str[0]如果不等就找到了-1。具体实现看下面代码：

class Solution {
public:
    char *strStr(char *haystack, char *needle) {
        if(haystack == NULL)
            return NULL;
        if(needle == NULL || strlen(needle) == 0)
            return haystack;
        int n = strlen(haystack);
        int m = strlen(needle);

        int *next = new int[m];
        CalcNext(needle,m,next);
        int i = 0;
        int j = 0;
        while(i < n){   //当且仅当j==-1和i，j指向的相等的时候，i++。
            if(j == -1 || haystack[i] == needle[j]){
                ++j;
                ++i;
            }else
                j = next[j];    //如果不相等，找到下一个j
            if(j == m){
                return haystack+i-j;
            }
        }
        return NULL;
    }
    void CalcNext(const char*str,int size,int *next){
        if(!str || !next || size<=0)
            return ;
        next[0] = -1;
        for(int i = 1;i < size;i++){
            int j = i-1;    //指向要求的i的前一个，因为第i个表示的是i-1的长度
            int index = next[j];    //找到j-1对应的长度index，然后str[index]和str[j]相比，就是看是否长度要增加
            while(index >= 0 && str[index] != str[j])
                index = next[index];    //如果不相等，就再看index-1所对应的长度next[index]
            if(index < 0)
                next[i] = 0;
            else
                next[i] = index + 1;
        }
    }
};

方案三：简易版Boyer Moore法

void bmSkipTable(char *ch, vector<int> &skipTable)
	{
		if (!ch) return;
		skipTable.resize(26);
		int m = strlen(ch);

		for (int i = 0; i < m; i++)
		{
			skipTable[ch[i] - 'a'] = i;
		}
	}
	char *bmStrStr(char *haystack, char *needle)
	{
		if(!haystack || !needle) return haystack;
		int n = strlen(haystack);
		int m = strlen(needle);

		vector<int> skipTable;
		bmSkipTable(needle, skipTable);

		int skip = 0;
		for (int i = 0; i <= n-m; i+=skip)
		{
			skip = 0;
			for (int j = m-1; j >= 0; j--)
			{
				if (haystack[i+j] != needle[j])
				{
					skip = j - skipTable[haystack[i+j] - 'a'];
					if (skip < 1) skip = 1;
					break;
				}
			}
			if (skip == 0) return haystack + i;
		}
		return nullptr;
	}