Merge pull request #1 from youngyangyang04/master

同步

Author: Younglesszzz

.DS_Store

@@ -5,10 +5,11 @@
 
 > 1. **介绍**：本项目是一套完整的刷题计划，旨在帮助大家少走弯路，循序渐进学算法，[关注作者](#关于作者)
 > 2. **PDF版本** ： [「代码随想录」算法精讲 PDF 版本](https://programmercarl.com/other/algo_pdf.html) 。
-> 3. **刷题顺序** ： README已经将刷题顺序排好了，按照顺序一道一道刷就可以。
-> 4. **学习社区** : 一起学习打卡/面试技巧/如何选择offer/大厂内推/职场规则/简历修改/技术分享/程序人生。欢迎加入[「代码随想录」知识星球](https://programmercarl.com/other/kstar.html) 。
-> 5. **提交代码**：本项目统一使用C++语言进行讲解，但已经有Java、Python、Go、JavaScript等等多语言版本，感谢[这里的每一位贡献者](https://github.com/youngyangyang04/leetcode-master/graphs/contributors)，如果你也想贡献代码点亮你的头像，[点击这里](https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A)了解提交代码的方式。
-> 6. **转载须知** ：以下所有文章皆为我（[程序员Carl](https://github.com/youngyangyang04)）的原创。引用本项目文章请注明出处，发现恶意抄袭或搬运，会动用法律武器维护自己的权益。让我们一起维护一个良好的技术创作环境！
+> 3. **最强八股文：**：[代码随想录知识星球精华PDF](https://www.programmercarl.com/other/kstar_baguwen.html)
+> 4. **刷题顺序** ： README已经将刷题顺序排好了，按照顺序一道一道刷就可以。
+> 5. **学习社区** : 一起学习打卡/面试技巧/如何选择offer/大厂内推/职场规则/简历修改/技术分享/程序人生。欢迎加入[「代码随想录」知识星球](https://programmercarl.com/other/kstar.html) 。
+> 6. **提交代码**：本项目统一使用C++语言进行讲解，但已经有Java、Python、Go、JavaScript等等多语言版本，感谢[这里的每一位贡献者](https://github.com/youngyangyang04/leetcode-master/graphs/contributors)，如果你也想贡献代码点亮你的头像，[点击这里](https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A)了解提交代码的方式。
+> 7. **转载须知** ：以下所有文章皆为我（[程序员Carl](https://github.com/youngyangyang04)）的原创。引用本项目文章请注明出处，发现恶意抄袭或搬运，会动用法律武器维护自己的权益。让我们一起维护一个良好的技术创作环境！
 
 <p align="center">
 <a href="programmercarl.com" target="_blank">
@@ -88,8 +89,7 @@
 
 ## 前序
 
-* [「代码随想录」后序安排](https://mp.weixin.qq.com/s/4eeGJREy6E-v6D7cR_5A4g)
-* [「代码随想录」学习社区](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
+* [「代码随想录」学习社区](https://programmercarl.com/other/kstar.html)
 
 
 * 编程语言
@@ -123,7 +123,7 @@
 
 * 算法性能分析
     * [关于时间复杂度，你不知道的都在这里！](./problems/前序/关于时间复杂度，你不知道的都在这里！.md)
-    * [$O(n)$的算法居然超时了，此时的n究竟是多大？](./problems/前序/On的算法居然超时了，此时的n究竟是多大？.md)
+    * [O(n)的算法居然超时了，此时的n究竟是多大？](./problems/前序/On的算法居然超时了，此时的n究竟是多大？.md)
     * [通过一道面试题目，讲一讲递归算法的时间复杂度！](./problems/前序/通过一道面试题目，讲一讲递归算法的时间复杂度！.md)
     * [本周小结！（算法性能分析系列一）](./problems/周总结/20201210复杂度分析周末总结.md)
     * [关于空间复杂度，可能有几个疑问？](./problems/前序/关于空间复杂度，可能有几个疑问？.md)

README.md

@@ -462,7 +462,92 @@ var longestPalindrome = function(s) {
 };
 ```
 
+## C
+动态规划:
+```c
+//初始化dp数组，全部初始为false
+bool **initDP(int strLen) {
+    bool **dp = (bool **)malloc(sizeof(bool *) * strLen);
+    int i, j;
+    for(i = 0; i < strLen; ++i) {
+        dp[i] = (bool *)malloc(sizeof(bool) * strLen);
+        for(j = 0; j < strLen; ++j)
+            dp[i][j] = false;
+    }
+    return dp;
+}
 
+char * longestPalindrome(char * s){
+    //求出字符串长度
+    int strLen = strlen(s);
+    //初始化dp数组，元素初始化为false
+    bool **dp = initDP(strLen);
+    int maxLength = 0, left = 0, right = 0;
+
+    //从下到上，从左到右遍历
+    int i, j;
+    for(i = strLen - 1; i >= 0; --i) {
+        for(j = i; j < strLen; ++j) {
+            //若当前i与j所指字符一样
+            if(s[i] == s[j]) {
+                //若i、j指向相邻字符或同一字符，则为回文字符串
+                if(j - i <= 1)
+                    dp[i][j] = true;
+                //若i+1与j-1所指字符串为回文字符串，则i、j所指字符串为回文字符串
+                else if(dp[i + 1][j - 1])
+                    dp[i][j] = true;
+            }
+            //若新的字符串的长度大于之前的最大长度，进行更新
+            if(dp[i][j] && j - i + 1 > maxLength) {
+                maxLength = j - i + 1;
+                left = i;
+                right = j;
+            }
+        }
+    }
+    //复制回文字符串，并返回
+    char *ret = (char*)malloc(sizeof(char) * (maxLength + 1));
+    memcpy(ret, s + left, maxLength);
+    ret[maxLength] = 0;
+    return ret;
+}
+```
+
+双指针:
+```c
+int left, maxLength;
+void extend(char *str, int i, int j, int size) {
+    while(i >= 0 && j < size && str[i] == str[j]) {
+        //若当前子字符串长度大于最长的字符串长度，进行更新
+        if(j - i + 1 > maxLength) {
+            maxLength = j - i + 1;
+            left = i;
+        }
+        //左指针左移，右指针右移。扩大搜索范围
+        ++j, --i;
+    }
+}
+
+char * longestPalindrome(char * s){
+    left = right = maxLength = 0;
+    int size = strlen(s);
+
+    int i;
+    for(i = 0; i < size; ++i) {
+        //长度为单数的子字符串
+        extend(s, i, i, size);
+        //长度为双数的子字符串
+        extend(s, i, i + 1, size);
+    }
+
+    //复制子字符串
+    char *subStr = (char *)malloc(sizeof(char) * (maxLength + 1));
+    memcpy(subStr, s + left, maxLength);
+    subStr[maxLength] = 0;
+
+    return subStr;
+}
+```
 
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0005.最长回文子串.md

@@ -138,8 +138,12 @@ public:
                 */
                 if (nums[i] + nums[left] + nums[right] > 0) {
                     right--;
+                    // 当前元素不合适了，可以去重
+                    while (left < right && nums[right] == nums[right + 1]) right--;
                 } else if (nums[i] + nums[left] + nums[right] < 0) {
                     left++;
+                    // 不合适，去重
+                    while (left < right && nums[left] == nums[left - 1]) left++;
                 } else {
                     result.push_back(vector<int>{nums[i], nums[left], nums[right]});
                     // 去重逻辑应该放在找到一个三元组之后

problems/0015.三数之和.md

@@ -91,9 +91,13 @@ public:
                     // nums[k] + nums[i] + nums[left] + nums[right] > target 会溢出
                     if (nums[k] + nums[i] > target - (nums[left] + nums[right])) {
                         right--;
+                        // 当前元素不合适了，可以去重
+                        while (left < right && nums[right] == nums[right + 1]) right--;
                     // nums[k] + nums[i] + nums[left] + nums[right] < target 会溢出
                     } else if (nums[k] + nums[i]  < target - (nums[left] + nums[right])) {
                         left++;
+                        // 不合适，去重
+                        while (left < right && nums[left] == nums[left - 1]) left++;
                     } else {
                         result.push_back(vector<int>{nums[k], nums[i], nums[left], nums[right]});
                         // 去重逻辑应该放在找到一个四元组之后

problems/0018.四数之和.md

@@ -159,7 +159,7 @@ class Solution {
 ```
 
 Python：
-```python3
+```python
 # 方法一，仅使用栈，更省空间
 class Solution:
     def isValid(self, s: str) -> bool:
@@ -180,7 +180,7 @@ class Solution:
         return True if not stack else False
 ```
 
-```python3
+```python
 # 方法二，使用字典
 class Solution:
     def isValid(self, s: str) -> bool:
@@ -283,8 +283,60 @@ var isValid = function(s) {
 };
 ```
 
+TypeScript:
+
+版本一：普通版
+
+```typescript
+function isValid(s: string): boolean {
+    let helperStack: string[] = [];
+    for (let i = 0, length = s.length; i < length; i++) {
+        let x: string = s[i];
+        switch (x) {
+            case '(':
+                helperStack.push(')');
+                break;
+            case '[':
+                helperStack.push(']');
+                break;
+            case '{':
+                helperStack.push('}');
+                break;
+            default:
+                if (helperStack.pop() !== x) return false;
+                break;
+        }
+    }
+    return helperStack.length === 0;
+};
+```
+
+版本二：优化版
+
+```typescript
+function isValid(s: string): boolean {
+    type BracketMap = {
+        [index: string]: string;
+    }
+    let helperStack: string[] = [];
+    let bracketMap: BracketMap = {
+        '(': ')',
+        '[': ']',
+        '{': '}'
+    }
+    for (let i of s) {
+        if (bracketMap.hasOwnProperty(i)) {
+            helperStack.push(bracketMap[i]);
+        } else if (i !== helperStack.pop()) {
+            return false;
+        }
+    }
+    return helperStack.length === 0;
+};
+```
 
 Swift
+
 ```swift
 func isValid(_ s: String) -> Bool {
     var stack = [String.Element]()

problems/0020.有效的括号.md

@@ -106,6 +106,37 @@ public:
 
 旧文链接：[数组：就移除个元素很难么？](https://programmercarl.com/0027.移除元素.html)
 
+```CPP
+/**
+* 相向双指针方法，基于元素顺序可以改变的题目描述改变了元素相对位置，确保了移动最少元素
+* 时间复杂度：$O(n)$
+* 空间复杂度：$O(1)$
+*/
+class Solution {
+public:
+    int removeElement(vector<int>& nums, int val) {
+        int leftIndex = 0;
+        int rightIndex = nums.size() - 1;
+        while (leftIndex <= rightIndex) {
+            // 找左边等于val的元素
+            while (leftIndex <= rightIndex && nums[leftIndex] != val){
+                ++leftIndex;
+            }
+            // 找右边不等于val的元素
+            while (leftIndex <= rightIndex && nums[rightIndex] == val) {
+                -- rightIndex;
+            }
+            // 将右边不等于val的元素覆盖左边等于val的元素
+            if (leftIndex < rightIndex) {
+                nums[leftIndex++] = nums[rightIndex--];
+            }
+        }
+        return leftIndex;   // leftIndex一定指向了最终数组末尾的下一个元素
+    }
+};
+```
+
+  
 ## 相关题目推荐
 
 * 26.删除排序数组中的重复项
@@ -142,7 +173,7 @@ class Solution {
 
 Python：
 
-```python3
+```python
 class Solution:
     """双指针法
     时间复杂度：O(n)

problems/0027.移除元素.md

@@ -929,6 +929,83 @@ var strStr = function (haystack, needle) {
 };
 ```
 
+TypeScript版本：
+
+> 前缀表统一减一
+
+```typescript
+function strStr(haystack: string, needle: string): number {
+    function getNext(str: string): number[] {
+        let next: number[] = [];
+        let j: number = -1;
+        next[0] = j;
+        for (let i = 1, length = str.length; i < length; i++) {
+            while (j >= 0 && str[i] !== str[j + 1]) {
+                j = next[j];
+            }
+            if (str[i] === str[j + 1]) {
+                j++;
+            }
+            next[i] = j;
+        }
+        return next;
+    }
+    if (needle.length === 0) return 0;
+    let next: number[] = getNext(needle);
+    let j: number = -1;
+    for (let i = 0, length = haystack.length; i < length; i++) {
+        while (j >= 0 && haystack[i] !== needle[j + 1]) {
+            j = next[j];
+        }
+        if (haystack[i] === needle[j + 1]) {
+            if (j === needle.length - 2) {
+                return i - j - 1;
+            }
+            j++;
+        }
+    }
+    return -1;
+};
+```
+
+> 前缀表不减一
+
+```typescript
+// 不减一版本
+function strStr(haystack: string, needle: string): number {
+    function getNext(str: string): number[] {
+        let next: number[] = [];
+        let j: number = 0;
+        next[0] = j;
+        for (let i = 1, length = str.length; i < length; i++) {
+            while (j > 0 && str[i] !== str[j]) {
+                j = next[j - 1];
+            }
+            if (str[i] === str[j]) {
+                j++;
+            }
+            next[i] = j;
+        }
+        return next;
+    }
+    if (needle.length === 0) return 0;
+    let next: number[] = getNext(needle);
+    let j: number = 0;
+    for (let i = 0, length = haystack.length; i < length; i++) {
+        while (j > 0 && haystack[i] !== needle[j]) {
+            j = next[j - 1];
+        }
+        if (haystack[i] === needle[j]) {
+            if (j === needle.length - 1) {
+                return i - j;
+            }
+            j++;
+        }
+    }
+    return -1;
+}
+```
+
 Swift 版本
 
 > 前缀表统一减一

problems/0028.实现strStr.md

@@ -81,7 +81,7 @@ public:
             for (int j = nums.size() - 1; j > i; j--) {
                 if (nums[j] > nums[i]) {
                     swap(nums[j], nums[i]);
-                    sort(nums.begin() + i + 1, nums.end());
+                    reverse(nums.begin() + i + 1, nums.end());
                     return;
                 }
             }

problems/0031.下一个排列.md

@@ -246,7 +246,7 @@ func searchInsert(nums []int, target int) int {
 ```
 
 ### Python 
-```python3
+```python
 class Solution:
     def searchInsert(self, nums: List[int], target: int) -> int:
         left, right = 0, len(nums) - 1