Merge branch 'youngyangyang04:master' into master

Author: jinyule

problems/0031.下一个排列.md

@@ -120,8 +120,50 @@ class Solution {
 ```
 
 ## Python
-
+>直接使用sorted()不符合题意
+```python
+class Solution:
+    def nextPermutation(self, nums: List[int]) -> None:
+        """
+        Do not return anything, modify nums in-place instead.
+        """
+        for i in range(len(nums)-1, -1, -1):
+            for j in range(len(nums)-1, i, -1):
+                if nums[j] > nums[i]:
+                    nums[j], nums[i] = nums[i], nums[j]
+                    nums[i+1:len(nums)] = sorted(nums[i+1:len(nums)])
+                    return
+        nums.sort()
+```
+>另一种思路
 ```python
+class Solution:
+  '''
+  抛砖引玉：因题目要求“必须原地修改，只允许使用额外常数空间”，python内置sorted函数以及数组切片+sort()无法使用。  
+  故选择另一种算法暂且提供一种python思路
+  '''
+    def nextPermutation(self, nums: List[int]) -> None:
+        """
+        Do not return anything, modify nums in-place instead.
+        """
+        length = len(nums)
+        for i in range(length-1, 0, -1):
+            if nums[i-1] < nums[i]:
+                for j in range(length-1, 0, -1):
+                    if nums[j] > nums[i-1]:
+                        nums[i-1], nums[j] = nums[j], nums[i-1]
+                        break
+                self.reverse(nums, i, length-1)
+                break
+        else:
+            # 若正常结束循环，则对原数组直接翻转
+            self.reverse(nums, 0, length-1)
+
+    def reverse(self, nums: List[int], low: int, high: int) -> None:
+        while low < high:
+            nums[low], nums[high] = nums[high], nums[low]
+            low += 1
+            high -= 1
 ```
 
 ## Go

problems/0053.最大子序和.md

@@ -161,6 +161,25 @@ class Solution {
 }
 ```
 
+```java
+// DP 方法
+class Solution {
+    public int maxSubArray(int[] nums) {
+        int ans = Integer.MIN_VALUE;
+        int[] dp = new int[nums.length];
+        dp[0] = nums[0];
+        ans = dp[0];
+
+        for (int i = 1; i < nums.length; i++){
+            dp[i] = Math.max(dp[i-1] + nums[i], nums[i]);
+            ans = Math.max(dp[i], ans);
+        }
+
+        return ans;
+    }
+}
+```
+
 Python：
 ```python
 class Solution:

problems/0106.从中序与后序遍历序列构造二叉树.md

@@ -792,30 +792,27 @@ func findRootIndex(target int,inorder []int) int{
 
 ```javascript
 var buildTree = function(inorder, postorder) {
-    if (!postorder.length) return null
-    
-    let root = new TreeNode(postorder[postorder.length - 1])
-    
-    let index = inorder.findIndex(number => number === root.val)
-    
-    root.left = buildTree(inorder.slice(0, index), postorder.slice(0, index))
-    root.right = buildTree(inorder.slice(index + 1, inorder.length), postorder.slice(index, postorder.length - 1))
-    
-    return root
+    if (!preorder.length) return null;
+    const rootVal = postorder.pop(); // 从后序遍历的数组中获取中间节点的值， 即数组最后一个值
+    let rootIndex = inorder.indexOf(rootVal); // 获取中间节点在中序遍历中的下标
+    const root = new TreeNode(rootVal); // 创建中间节点
+    root.left = buildTree(inorder.slice(0, rootIndex), postorder.slice(0, rootIndex)); // 创建左节点
+    root.right = buildTree(inorder.slice(rootIndex + 1), postorder.slice(rootIndex)); // 创建右节点
+    return root;
 };
 ```
 
 从前序与中序遍历序列构造二叉树
 
 ```javascript
 var buildTree = function(preorder, inorder) {
-    if(!preorder.length)
-        return null;
-    let root = new TreeNode(preorder[0]);
-    let mid = inorder.findIndex((number) => number === root.val);
-    root.left = buildTree(preorder.slice(1, mid + 1), inorder.slice(0, mid));
-    root.right = buildTree(preorder.slice(mid + 1, preorder.length), inorder.slice(mid + 1, inorder.length));
-    return root;
+  if (!preorder.length) return null;
+  const rootVal = preorder.shift(); // 从前序遍历的数组中获取中间节点的值， 即数组第一个值
+  const index = inorder.indexOf(rootVal); // 获取中间节点在中序遍历中的下标
+  const root = new TreeNode(rootVal); // 创建中间节点
+  root.left = buildTree(preorder.slice(0, index), inorder.slice(0, index)); // 创建左节点
+  root.right = buildTree(preorder.slice(index), inorder.slice(index + 1)); // 创建右节点
+  return root;
 };
 ```
 

problems/0108.将有序数组转换为二叉搜索树.md

@@ -375,8 +375,25 @@ var sortedArrayToBST = function (nums) {
 };
 ```
 
+## C
+递归
+```c
+struct TreeNode* traversal(int* nums, int left, int right) {
+    if (left > right) 
+        return NULL;
+    int mid = left + ((right - left) / 2);
+    struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
+    root->val = nums[mid];
+    root->left = traversal(nums, left, mid - 1);
+    root->right = traversal(nums, mid + 1, right);
+    return root;
+}
 
-
+struct TreeNode* sortedArrayToBST(int* nums, int numsSize) {
+    struct TreeNode* root = traversal(nums, 0, numsSize - 1);
+    return root;
+}
+```
 
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)

problems/0122.买卖股票的最佳时机II（动态规划）.md

@@ -200,6 +200,31 @@ class Solution:
 
 Go：
 
+```go
+func maxProfit(prices []int) int {
+    //创建数组
+    dp:=make([][]int,len(prices))
+    for i:=0;i<len(prices);i++{
+        dp[i]=make([]int,2)
+    }
+    dp[0][0]=-prices[0]
+    dp[0][1]=0
+    for i:=1;i<len(prices);i++{
+        dp[i][0]=max(dp[i-1][0],dp[i-1][1]-prices[i])
+        dp[i][1]=max(dp[i-1][1],dp[i-1][0]+prices[i])
+    }
+    return dp[len(prices)-1][1]
+}
+func max(a,b int)int{
+    if a<b{
+        return b
+    }
+    return a
+}
+```
+
+
+
 Javascript：
 ```javascript
 // 方法一：动态规划（dp 数组）

problems/0123.买卖股票的最佳时机III.md

@@ -278,6 +278,38 @@ class Solution:
         return dp[4]
 ```
 
+Go:
+
+```go
+func maxProfit(prices []int) int {
+    dp:=make([][]int,len(prices))
+    for i:=0;i<len(prices);i++{
+        dp[i]=make([]int,5)
+    }
+    dp[0][0]=0
+    dp[0][1]=-prices[0]
+    dp[0][2]=0
+    dp[0][3]=-prices[0]
+    dp[0][4]=0
+    for i:=1;i<len(prices);i++{
+        dp[i][0]=dp[i-1][0]
+        dp[i][1]=max(dp[i-1][1],dp[i-1][0]-prices[i])
+        dp[i][2]=max(dp[i-1][2],dp[i-1][1]+prices[i])
+        dp[i][3]=max(dp[i-1][3],dp[i-1][2]-prices[i])
+        dp[i][4]=max(dp[i-1][4],dp[i-1][3]+prices[i])
+    }
+    return dp[len(prices)-1][4]
+}
+func max(a,b int)int{
+    if a>b{
+        return a
+    }
+    return b
+}
+```
+
+
+
 JavaScript：
 
 > 版本一：

problems/0151.翻转字符串里的单词.md

@@ -300,6 +300,94 @@ class Solution {
 }
 ```
 
+```java
+//解法二：创建新字符数组填充。时间复杂度O(n)
+class Solution {
+    public String reverseWords(String s) {
+        //源字符数组
+        char[] initialArr = s.toCharArray();
+        //新字符数组
+        char[] newArr = new char[initialArr.length+1];//下面循环添加"单词 "，最终末尾的空格不会返回
+        int newArrPos = 0;
+        //i来进行整体对源字符数组从后往前遍历
+        int i = initialArr.length-1;
+        while(i>=0){
+            while(i>=0 && initialArr[i] == ' '){i--;}  //跳过空格
+            //此时i位置是边界或!=空格，先记录当前索引，之后的while用来确定单词的首字母的位置
+            int right = i;
+            while(i>=0 && initialArr[i] != ' '){i--;} 
+            //指定区间单词取出(由于i为首字母的前一位，所以这里+1,)，取出的每组末尾都带有一个空格
+            for (int j = i+1; j <= right; j++) {
+                newArr[newArrPos++] = initialArr[j];
+                if(j == right){
+                    newArr[newArrPos++] = ' ';//空格
+                }
+            }
+        }
+        //若是原始字符串没有单词，直接返回空字符串；若是有单词，返回0-末尾空格索引前范围的字符数组(转成String返回)
+        if(newArrPos == 0){
+            return "";
+        }else{
+            return new String(newArr,0,newArrPos-1);
+        }
+    }
+}
+```
+
+```java
+//解法三：双反转+移位，在原始数组上进行反转。空间复杂度O(1)
+class Solution {
+    /**
+     * 思路：
+     *	①反转字符串  "the sky is blue " => " eulb si yks eht"
+     *	②遍历 " eulb si yks eht"，每次先对某个单词进行反转再移位
+     *	   这里以第一个单词进行为演示：" eulb si yks eht" ==反转=> " blue si yks eht" ==移位=> "blue si yks eht"
+     */
+    public String reverseWords(String s) {
+        //步骤1：字符串整体反转（此时其中的单词也都反转了）
+        char[] initialArr = s.toCharArray();
+        reverse(initialArr, 0, s.length() - 1);
+        int k = 0;
+        for (int i = 0; i < initialArr.length; i++) {
+            if (initialArr[i] == ' ') {
+                continue;
+            }
+            int tempCur = i;
+            while (i < initialArr.length && initialArr[i] != ' ') {
+                i++;
+            }
+            for (int j = tempCur; j < i; j++) {
+                if (j == tempCur) { //步骤二：二次反转
+                    reverse(initialArr, tempCur, i - 1);//对指定范围字符串进行反转，不反转从后往前遍历一个个填充有问题
+                }
+                //步骤三：移动操作
+                initialArr[k++] = initialArr[j];
+                if (j == i - 1) { //遍历结束
+                    //避免越界情况，例如=> "asdasd df f"，不加判断最后就会数组越界
+                    if (k < initialArr.length) {
+                        initialArr[k++] = ' ';
+                    }
+                }
+            }
+        }
+        if (k == 0) {
+            return "";
+        } else {
+            //参数三：以防出现如"asdasd df f"=>"f df asdasd"正好凑满不需要省略空格情况
+            return new String(initialArr, 0, (k == initialArr.length) && (initialArr[k - 1] != ' ') ? k : k - 1);
+        }
+    }
+
+    public void reverse(char[] chars, int begin, int end) {
+        for (int i = begin, j = end; i < j; i++, j--) {
+            chars[i] ^= chars[j];
+            chars[j] ^= chars[i];
+            chars[i] ^= chars[j];
+        }
+    }
+}
+```
+
 python:
 
 ```Python

problems/0188.买卖股票的最佳时机IV.md

@@ -276,6 +276,42 @@ class Solution:
 ```
 Go：
 
+```go
+func maxProfit(k int, prices []int) int {
+    if len(prices)==0{
+        return 0
+    }
+    dp:=make([][]int,len(prices))
+    for i:=0;i<len(prices);i++{
+        dp[i]=make([]int,2*k+1)
+    }
+    for i:=1;i<len(dp[0]);i++{
+        if i%2!=0{
+            dp[0][i]=-prices[0]
+        }
+    }
+    for i:=1;i<len(prices);i++{
+        dp[i][0]=dp[i-1][0]
+        for j:=1;j<len(dp[0]);j++{
+            if j%2!=0{
+                 dp[i][j]=max(dp[i-1][j],dp[i-1][j-1]-prices[i])
+            }else {
+                dp[i][j]=max(dp[i-1][j],dp[i-1][j-1]+prices[i])
+            }
+        }
+    }
+    return dp[len(prices)-1][2*k]
+}
+func max(a,b int)int{
+    if a>b{
+        return a
+    }
+    return b
+}
+```
+
+
+
 
 Javascript：
 

problems/0202.快乐数.md

@@ -215,6 +215,23 @@ var isHappy = function(n) {
     }
     return n === 1;
 };
+
+// 方法四：使用Set()，求和用reduce
+var isHappy = function(n) {
+    let set = new Set();
+    let totalCount;
+    while(totalCount !== 1) {
+        let arr = (''+(totalCount || n)).split('');
+        totalCount = arr.reduce((total, num) => {
+            return total + num * num
+        }, 0)
+        if (set.has(totalCount)) {
+            return false;
+        }
+        set.add(totalCount);
+    }
+    return true;
+};
 ```
 
 Swift：