28

Author: wind-liang

SUMMARY.md

@@ -28,4 +28,5 @@
 * [25. Reverse Nodes in k-Group](leetCode-25-Reverse-Nodes-in-k-Group.md)
 * [26. Remove Duplicates from Sorted Array](leetCode-26-Remove-Duplicates-from-Sorted-Array.md)
 * [27. Remove Element](leetCode-27-Remove-Element.md)
+* [28. Implement strStr()](leetCode-28-Implement-strStr.md)
 * [79. Word Search](leetCode-79-Word-Search.md)

leetCode-28-Implement-strStr.md

@@ -0,0 +1,55 @@
+# 题目描述（简单难度）
+
+![](https://windliang.oss-cn-beijing.aliyuncs.com/28.jpg)
+
+返回一个字符串 needle 在另一个字符串 haystack 中开始的位置，如果不存在就返回 -1 ，如果 needle 长度是 0 ，就返回 0 。
+
+就是一一比较就好，看下代码吧。
+
+```java
+public int strStr(String haystack, String needle) {
+    if (needle.length() == 0) {
+        return 0;
+    }
+    int j = 0;
+    //遍历每个字符
+    for (int i = 0; i < haystack.length(); i++) {
+        //相等的话计数加 1 
+        if (haystack.charAt(i) == needle.charAt(j)) {
+            j++;
+            //长度够了就返回
+            if (j == needle.length()) {
+                return i - j + 1;
+            }
+            // 不相等的话 j 清零，
+            // 并且 i 回到最初的位置，之后就进入 for 循环中的 i++，从下个位置继续判断
+        } else {
+            i = i - j;
+            j = 0;
+        }
+    }
+    return -1;
+}
+```
+
+时间复杂度：假设 haystack 和 needle 的长度分别是 n 和 k，对于每一个 i ，我们最多执行 k - 1 次，总共会有 n 个 i ，所以时间复杂度是 O（kn）。
+
+空间复杂度：O（1）。
+
+我们再看下别人的[代码](https://leetcode.com/problems/implement-strstr/discuss/12807/Elegant-Java-solution)，用两个 for 循环。但本质其实是一样的，但可能会更好理解些吧。
+
+```java
+public int strStr(String haystack, String needle) {
+  for (int i = 0; ; i++) {
+    for (int j = 0; ; j++) {
+      if (j == needle.length()) return i;
+      if (i + j == haystack.length()) return -1;
+      if (needle.charAt(j) != haystack.charAt(i + j)) break;
+    }
+  }
+}
+```
+
+# 总
+
+总的来说，还是比较简单的，就是简单的遍历就实现了。

leetCode28-Implement-strStr().md

@@ -0,0 +1,55 @@
+# 题目描述（简单难度）
+
+![](https://windliang.oss-cn-beijing.aliyuncs.com/28.jpg)
+
+返回一个字符串 needle 在另一个字符串 haystack 中开始的位置，如果不存在就返回 -1 ，如果 needle 长度是 0 ，就返回 0 。
+
+就是一一比较就好，看下代码吧。
+
+```java
+public int strStr(String haystack, String needle) {
+    if (needle.length() == 0) {
+        return 0;
+    }
+    int j = 0;
+    //遍历每个字符
+    for (int i = 0; i < haystack.length(); i++) {
+        //相等的话计数加 1 
+        if (haystack.charAt(i) == needle.charAt(j)) {
+            j++;
+            //长度够了就返回
+            if (j == needle.length()) {
+                return i - j + 1;
+            }
+            // 不相等的话 j 清零，
+            // 并且 i 回到最初的位置，之后就进入 for 循环中的 i++，从下个位置继续判断
+        } else {
+            i = i - j;
+            j = 0;
+        }
+    }
+    return -1;
+}
+```
+
+时间复杂度：假设 haystack 和 needle 的长度分别是 n 和 k，由于不匹配的时候，i 会回到开始匹配的时候的位置，所以每一个 i 都会执行到，总共会有 n 个 i ，并且对于每个 i 最多执行 k - 1 次，所以时间复杂度是 O（kn）。
+
+空间复杂度：O（1）。
+
+我们再看下别人的[代码](https://leetcode.com/problems/implement-strstr/discuss/12807/Elegant-Java-solution)，用两个 for 循环。但本质其实是一样的，但可能会更好理解些吧。
+
+```java
+public int strStr(String haystack, String needle) {
+  for (int i = 0; ; i++) {
+    for (int j = 0; ; j++) {
+      if (j == needle.length()) return i;
+      if (i + j == haystack.length()) return -1;
+      if (needle.charAt(j) != haystack.charAt(i + j)) break;
+    }
+  }
+}
+```
+
+# 总
+
+总的来说，还是比较简单的，就是简单的遍历就实现了。