w1: stanley

swiftwind0405 · swiftwind0405 · commit c6ea6bc15825 · 2020-09-24T20:19:10.000+08:00
diff --git a/README.md b/README.md
@@ -385,7 +385,7 @@ LeetCode
 |30|[Substring with Concatenation of All Words](https://leetcode.com/problems/substring-with-concatenation-of-all-words/)| |Hard|
 |29|[Divide Two Integers](https://leetcode.com/problems/divide-two-integers/)| |Medium|
 |28|[Implement strStr()](https://leetcode.com/problems/implement-strstr/)| |Easy|
-|27|[Remove Element](https://leetcode.com/problems/remove-element/)| |Easy|
+|27|[Remove Element](https://leetcode.com/problems/remove-element/)| [js](./algorithms/removeElement/removeElement-js.md) |Easy|
 |26|[Remove Duplicates from Sorted Array](https://leetcode.com/problems/remove-duplicates-from-sorted-array/)| |Easy|
 |25|[Reverse Nodes in k-Group](https://leetcode.com/problems/reverse-nodes-in-k-group/)| |Hard|
 |24|[Swap Nodes in Pairs](https://leetcode.com/problems/swap-nodes-in-pairs/)| |Medium|
@@ -398,7 +398,7 @@ LeetCode
 |17|[Letter Combinations of a Phone Number](https://leetcode.com/problems/letter-combinations-of-a-phone-number/)| |Medium|
 |16|[3Sum Closest](https://leetcode.com/problems/3sum-closest/)| |Medium|
 |15|[3Sum](https://leetcode.com/problems/3sum/)| |Medium|
-|14|[Longest Common Prefix](https://leetcode.com/problems/longest-common-prefix/)| |Easy|
+|14|[Longest Common Prefix](https://leetcode.com/problems/longest-common-prefix/)| [js](./algorithms/longestCommonPrefix/longestCommonPrefix-js.md) |Easy|
 |13|[Roman to Integer](https://leetcode.com/problems/roman-to-integer/)| |Easy|
 |12|[Integer to Roman](https://leetcode.com/problems/integer-to-roman/)| |Medium|
 |11|[Container With Most Water](https://leetcode.com/problems/container-with-most-water/)| |Medium|
diff --git a/algorithms/3Sum/3Sum-js.md b/algorithms/3Sum/3Sum-js.md
@@ -0,0 +1,104 @@
+# 15. 三数之和
+
+## 方法一：排序 + 双指针
+
+**解题思想：**
+
+这道题如果使用暴力求解法，也就是三重循环来枚举，首先时间复杂度是O(N^3)，还得使用哈希表来进行去重，得到最终的一个不重复的三元数组，时间复杂度与空间复杂度都非常高。
+
+可以通过先排序，再用三重循环，来保证循环的元素不重复。
+
+同时，对于每一重循环而言，相邻两次枚举的元素不能相同，否则也会造成重复。举个例子，如果排完序的数组为
+
+**代码：**
+
+```js
+[0, 1, 2, 2, 2, 3]
+ ^  ^  ^
+```
+
+当枚举的第一个三元数组是 (0, 1, 2)，后面一次枚举依旧是 (0, 1, 2)，因此要将第三重循环跳到一个完全不同的元素，即跳过2也就是最后一个元素3。
+
+用暴力法试一下：
+
+```js
+var threeSum = function (nums) {
+  nums = nums.sort((a, b) => a - b);
+  const len = nums.length,
+    result = [];
+
+  const check = (i, j, k) => nums[i] + nums[j] + nums[k] === 0;
+
+  for (let i = 0; i < len - 2; i++) {
+    if (i > 0 && nums[i] === nums[i - 1]) {
+      continue;
+    }
+
+    if (nums[i] === 0 && nums[i + 1] === 0 && nums[i + 2] === 0) {
+      result.push([0, 0, 0]);
+      break;
+    }
+
+    for (let j = i + 1; j < len - 1; j++) {
+      if (j > i + 1 && nums[j] === nums[j - 1]) {
+        continue;
+      }
+
+      for (let k = j + 1; k < len; k++) {
+        if (k > j + 1 && nums[k] === nums[k - 1]) {
+          continue;
+        }
+        check(i, j, k) && result.push([nums[i], nums[j], nums[k]]);
+      }
+    }
+  }
+  return result;
+};
+```
+
+时间复杂度仍然为 O(N^3)，这是无法接受的，因此需要进行优化。
+
+因为 a + b + c = 0，在保持 a 不变的前提下，随着 b 的增大，c 就会逐渐变小，因此我们让第三重循环的指针从最右边开始往右遍历。这样的话，将枚举的时间复杂度从 O(N^2)减少至 O(N)。这就是双指针的方法。
+
+这道题的难点在于重复项的判断。
+
+```js
+var threeSum = function(nums) {
+  const result = [];
+
+  const len = nums.length;
+  if (len < 3) {
+    return result;
+  }
+
+  nums = nums.sort((a, b) => a - b);
+  for (let i = 0; i < len; i++) {
+    // 如果当前数组大于0，则三数之和一定大于0，所以结束循环
+    if (nums[i] > 0) break;
+    // 重复项跳过循环
+    if (i > 0 && nums[i] === nums[i-1]) continue;
+    let L = i + 1;
+    let R = len - 1;
+    while (L < R) {
+      const sum = nums[i] + nums[L] + nums[R];
+      if (sum === 0) {
+        // 跳过重复项
+        result.push([nums[i], nums[L], nums[R]])
+        while (L < R && nums[L] === nums[L + 1]) L++;
+        while (L < R && nums[R] === nums[R - 1]) R--;
+        L++;
+        R--;
+      }
+      else if (sum < 0) L++;
+      else if (sum > 0) R--;
+    }
+  }
+  return result;
+};
+```
+
+**复杂度分析：**
+
+- 时间复杂度：O(N^2)。
+
+- 空间复杂度：O(logN)。额外排序的空间复杂度为 O(logN)。使用了一个额外的数组存储了 nums 的副本并进行排序，空间复杂度为 O(N)。
diff --git a/algorithms/longestCommonPrefix/longestCommonPrefix-js.md b/algorithms/longestCommonPrefix/longestCommonPrefix-js.md
@@ -0,0 +1,132 @@
+# 14. 最长公共前缀
+
+## 方法一：取第一个字符串，与剩下的依次比较
+
+写法一：
+
+**代码：**
+
+```js
+var longestCommonPrefix = function(strs) {
+  if (strs.length == 0) return "";
+  let ans = strs[0];
+  for (let i = 1; i < strs.length; i++) {
+    let j = 0;
+    for (; j < ans.length && j < strs[i].length; j++) {
+      if (ans[j] != strs[i][j]) break;
+    }
+    ans = ans.substr(0, j);
+    if (ans === "") return ans;
+  }
+  return ans;
+};
+```
+
+写法二：
+
+**代码：**
+
+```js
+var longestCommonPrefix = function(strs) {
+	// 当字符串数组长度为 0 时则公共前缀为空，直接返回
+  if (strs.length === 0) return '';
+	// 令最长公共前缀 ans 的值为第一个字符串，进行初始化
+  const ans = strs[0];
+  const len = ans.length;
+	// ans 是空字符串的特殊情况
+	if (len === 0) return '';
+  for (let i = 0; i < len; i++) {
+      if (!strs.every(str => str[i] === ans[i])) {
+				// 首次判定的时候就有不满足的项，直接抛空出去
+	      if (i === 0) return '';
+				// 当有不满足项出现的时候，把之前满足的字符串抛出去
+	      return ans.slice(0, i);
+      }
+  }
+	// 循环跑完也没有return出去，说明全部满足，把判断的这个字符return出去
+  return ans;
+};
+```
+
+**复杂度分析：**
+
+- 时间复杂度：O(n)，n 是数组的长度
+- 空间复杂度：O(1)
+
+## 方法二：直接比较最长字符串与最短字符串
+
+**解题思路：**
+
+找出最大字符串与最小字符串，然后比较出来的公共前缀也为其它字符串的公共前缀。
+
+这里需要注意的是，比较大小是按照字符的大小，比如abac是小于abc的。
+
+**代码：**
+
+```js
+var longestCommonPrefix = function(strs) {
+	if (strs === null || strs.length === 0) return "";
+  if(strs.length === 1) return strs[0]
+  let min = 0, max = 0
+  for(let i = 1; i < strs.length; i++) {
+      if(strs[min] > strs[i]) min = i
+      if(strs[max] < strs[i]) max = i
+  }
+  for(let j = 0; j < strs[min].length; j++) {
+      if(strs[min].charAt(j) !== strs[max].charAt(j)) {
+          return strs[min].substring(0, j)
+      }
+  }
+  return strs[min];
+};
+```
+
+**复杂度分析：**
+
+- 时间复杂度：O(n+m)，n是数组的长度， m 是字符串数组中最短字符的长度
+- 空间复杂度：O(1)
+
+## 方法三：分治策略 归并思想
+
+**解题思路：**
+
+把问题分解为子问题：找2个字符串的最长公共前缀
+
+**代码：**
+
+```js
+var longestCommonPrefix = function(strs) {
+    if (strs === null || strs.length === 0) return "";
+    return lCPrefixRec(strs)
+};
+
+// 若分裂后的两个数组长度不为 1，则继续分裂
+// 直到分裂后的数组长度都为 1，
+// 然后比较获取最长公共前缀
+function lCPrefixRec(arr) {
+  let length = arr.length
+  if(length === 1) {
+    return arr[0]
+  }
+  let mid = Math.floor(length / 2),
+      left = arr.slice(0, mid),
+      right = arr.slice(mid, length)
+  return lCPrefixTwo(lCPrefixRec(left), lCPrefixRec(right))
+}
+
+// 求 str1 与 str2 的最长公共前缀
+function lCPrefixTwo(str1, str2) {
+    let j = 0
+    for(; j < str1.length && j < str2.length; j++) {
+        if(str1.charAt(j) !== str2.charAt(j)) {
+            break
+        }
+    }
+    return str1.substring(0, j)
+}
+```
+
+**复杂度分析：**
+
+- 时间复杂度：O(s)，s 是所有字符串中字符数量的总和
+- 空间复杂度：O(m*logn)，n是数组的长度，m为字符串数组中最长字符的长度
diff --git a/algorithms/removeElement/removeElement-js.md b/algorithms/removeElement/removeElement-js.md
@@ -0,0 +1,95 @@
+# 27. 移除元素
+
+直接对原数组中进行更改，返回目标数组的长度，超过这个长度的数组项可以继续留在原数组中，长度以内的项则就是结果项。
+
+## 方法一：直接覆盖
+
+**解题思想：**
+
+遇到不同于val的项，就将其直接覆盖到nums数组中，并记一次累加值，当遍历完之后，所有不同于val的项就都放到nums数组的前面了，而这个累加值就是这个前面数组的长度。
+
+**代码：**
+
+```js
+var removeElement = (nums, val) => {
+  let count= 0
+  for (let i = 0; i < nums.length; i++) {
+    if (nums[i] !== val) {
+      nums[count] = nums[i];
+      count++;
+    } 
+  }
+  return count;
+}
+```
+
+**复杂度分析：**
+
+- 时间复杂度：O(n)，就一次循环遍历
+
+## 方法二：双指针法
+
+**解题思想：**
+
+左指针在数组开始的位置，右指针在数组结尾的位置。当左指针的项等于val的时候，把右指针的项给拿过来，同时右指针往左移一位；而当等于的时候，左指针往右移一位。当两个指针相遇的时候，左指针的位置就是所有不等于val项的数组的长度。
+
+**代码：**
+
+```js
+var removeElement = function(nums, val) {
+  let L = 0, R = nums.length - 1;
+  while (L <= R) {
+    if (nums[L] === val) {
+      nums[L] = nums[R];
+      R--;
+    } else {
+      L++;
+    }
+  }
+  return L;
+};
+```
+
+## 方法三：直接删除元素
+
+遇到和val相同的项就直接用splice删除，后面的项就都会往前移一位。
+
+**代码：**
+
+```js
+var removeElement = function(nums, val) {
+  for (let i = 0; i < nums.length ; i++) {
+    if (nums[i] === val) {
+      nums.splice(i, 1);
+			// 指针 i 要 -1，新项需重新判定，不然会漏掉
+      i--;
+    }
+  }
+  return nums.length;
+};
+```
+
+> 为了避免遍历时执行多遍计算数组长度的操作，影响效率,，建议在循环开始以变量的形式缓存下数组长度，若在循环内部有可能改变数组长度，请务必慎重处理，避免数组越界。因此这里会改变数组长度的做法，是有危险的，不推荐。
+
+另一种写法：
+
+只要数组中还存在和val相同的项，就删除。
+
+```js
+var removeElement = (nums, val) => {
+  while (nums.indexOf(val) !== -1) {
+    nums.splice(nums.indexOf(val),1)
+  }
+  return nums.length
+}
+```
+
+**复杂度分析：**
+
+- 时间复杂度：O(n)
+
+    > 这几种方法都需要遍历一次数组，因此时间复杂度都是O(n)
+
+- 空间复杂度：O(1)
+
+    > 没有占用额外的空间
