力扣28题心得体会（暴力解法）

Implement strStr().

Return the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.

Clarification:

What should we return when needle is an empty string? This is a great question to ask during an interview.

For the purpose of this problem, we will return 0 when needle is an empty string. This is consistent to C's strstr() and Java's indexOf().

Example 1:

Input: haystack = "hello", needle = "ll"
Output: 2
Example 2:

Input: haystack = "aaaaa", needle = "bba"
Output: -1
Example 3:

Input: haystack = "", needle = ""
Output: 0

我的代码

class Solution {
public:
	int strStr(string haystack, string needle)
	{
		int size = needle.size();
        int size1 =  haystack.size();
        if(size == 0)
        {
            return 0;
        }
		for (int i = 0; i <size1 - size + 1; i++)
		{
			if (isSame(haystack.substr(i, size), needle))
			{
				return i;
			}
		}
		return -1;
	}
    bool isSame(string subhay, string needle)
	{
		for (int i = 0; i < needle.size(); i++)
			if (subhay[i] != needle[i])
				return false;
		return true;
	}
};

 思路：简单的暴力求解思路，利用一个判断的函数实现，函数传入一个和需要比较字符串一样大小的字串，返回一个bool类型作为判断条件。

 简化版本1

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

思路差异：核心思路一样，主要的差异在于在函数中设置一个flag变量，用变量记录实现过程中判断的结果变量一旦改为false就结束循环（相当于判断函数返回）。

小细节：

其中存在的flag变量初始化在循环中，代表每次循环都会重置再判断

下标的使用采用外层加内层，相当于把外层作为一个基础往后遍历（相当于传入子串）

 

简化版本2

class Solution {
public:
    int strStr(string s, string p) {
        int n = s.size(), m = p.size();
        for(int i = 0; i <= n - m; i++){
            int j = i, k = 0; 
            while(k < m and s[j] == p[k]){
                j++;
                k++;
            }
            if(k == m) return i;
        }
        return -1;
    }
};

 该版本设计的判断条件是遍历过后的下标，因为在如果不存在相同的子串，本次循环下标就不会顺利到达size的位置

该方法的  j = i； 语句就更清晰表达了将子串的意思。