Merge branch 'youngyangyang04:master' into master

problems/0112.路径总和.md

@@ -486,6 +486,92 @@ class Solution:
 
 Go：
 
+> 112. 路径总和
+
+```go
+//递归法
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func hasPathSum(root *TreeNode, targetSum int) bool {
+    var flage bool //找没找到的标志
+    if root==nil{
+        return flage
+    }
+    pathSum(root,0,targetSum,&flage)
+    return flage
+}
+func pathSum(root *TreeNode, sum int,targetSum int,flage *bool){
+    sum+=root.Val
+    if root.Left==nil&&root.Right==nil&&sum==targetSum{
+        *flage=true
+        return
+    }
+    if root.Left!=nil&&!(*flage){//左节点不为空且还没找到
+        pathSum(root.Left,sum,targetSum,flage)
+    } 
+    if root.Right!=nil&&!(*flage){//右节点不为空且没找到
+        pathSum(root.Right,sum,targetSum,flage)
+    }
+}
+```
+
+
+
+> 113 递归法
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func pathSum(root *TreeNode, targetSum int) [][]int {
+    var result [][]int//最终结果
+    if root==nil{
+        return result
+    }
+    var sumNodes []int//经过路径的节点集合
+    hasPathSum(root,&sumNodes,targetSum,&result)
+    return result
+}
+func hasPathSum(root *TreeNode,sumNodes *[]int,targetSum int,result *[][]int){
+    *sumNodes=append(*sumNodes,root.Val)
+    if root.Left==nil&&root.Right==nil{//叶子节点
+        fmt.Println(*sumNodes)
+        var sum int
+        var number int
+        for k,v:=range *sumNodes{//求该路径节点的和
+            sum+=v
+            number=k
+        }
+        tempNodes:=make([]int,number+1)//新的nodes接受指针里的值，防止最终指针里的值发生变动，导致最后的结果都是最后一个sumNodes的值
+        for k,v:=range *sumNodes{
+            tempNodes[k]=v
+        }
+        if sum==targetSum{
+            *result=append(*result,tempNodes)
+        }
+    }
+    if root.Left!=nil{
+        hasPathSum(root.Left,sumNodes,targetSum,result)
+        *sumNodes=(*sumNodes)[:len(*sumNodes)-1]//回溯
+    }
+    if root.Right!=nil{
+        hasPathSum(root.Right,sumNodes,targetSum,result)
+        *sumNodes=(*sumNodes)[:len(*sumNodes)-1]//回溯
+    }
+}
+```
+
 JavaScript：
 
 0112.路径总和

problems/0239.滑动窗口最大值.md

@@ -332,6 +332,66 @@ func maxSlidingWindow(nums []int, k int) []int {
 
 ```
 
+```go
+// 封装单调队列的方式解题
+type MyQueue struct {
+    queue []int
+}
+
+func NewMyQueue() *MyQueue {
+    return &MyQueue{
+        queue: make([]int, 0),
+    }
+}
+
+func (m *MyQueue) Front() int {
+    return m.queue[0]
+}
+
+func (m *MyQueue) Back() int {
+    return m.queue[len(m.queue)-1]
+}
+
+func (m *MyQueue) Empty() bool {
+    return len(m.queue) == 0
+}
+
+func (m *MyQueue) Push(val int) {
+    for !m.Empty() && val > m.Back() {
+        m.queue = m.queue[:len(m.queue)-1]
+    }
+    m.queue = append(m.queue, val)
+}
+
+func (m *MyQueue) Pop(val int) {
+    if !m.Empty() && val == m.Front() {
+        m.queue = m.queue[1:]
+    }
+}
+
+func maxSlidingWindow(nums []int, k int) []int {
+    queue := NewMyQueue()
+    length := len(nums)
+    res := make([]int, 0)
+    // 先将前k个元素放入队列
+    for i := 0; i < k; i++ {
+        queue.Push(nums[i])
+    }
+    // 记录前k个元素的最大值
+    res = append(res, queue.Front())
+
+    for i := k; i < length; i++ {
+        // 滑动窗口移除最前面的元素
+        queue.Pop(nums[i-k])
+        // 滑动窗口添加最后面的元素
+        queue.Push(nums[i])
+        // 记录最大值
+        res = append(res, queue.Front())
+    }
+    return res
+}
+```
+
 Javascript:
 ```javascript
 var maxSlidingWindow = function (nums, k) {

problems/0242.有效的字母异位词.md

@@ -130,7 +130,27 @@ class Solution:
         return True
 ```
 
+Python写法二（没有使用数组作为哈希表，只是介绍defaultdict这样一种解题思路）：
+
+```python
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+        from collections import defaultdict
+        
+        s_dict = defaultdict(int)
+        t_dict = defaultdict(int)
+
+        for x in s:
+            s_dict[x] += 1
+        
+        for x in t:
+            t_dict[x] += 1
+
+        return s_dict == t_dict
+```
+
 Go：
+
 ```go
 func isAnagram(s string, t string) bool {
     if len(s)!=len(t){

problems/0343.整数拆分.md

@@ -218,7 +218,7 @@ class Solution:
             # 假设对正整数 i 拆分出的第一个正整数是 j（1 <= j < i），则有以下两种方案：
             # 1) 将 i 拆分成 j 和 i−j 的和，且 i−j 不再拆分成多个正整数，此时的乘积是 j * (i-j)
             # 2) 将 i 拆分成 j 和 i−j 的和，且 i−j 继续拆分成多个正整数，此时的乘积是 j * dp[i-j]
-            for j in range(1, i):
+            for j in range(1, i - 1):
                 dp[i] = max(dp[i], max(j * (i - j), j * dp[i - j]))
         return dp[n]
 ```

problems/0404.左叶子之和.md

@@ -226,6 +226,71 @@ class Solution:
 ```
 Go：
 
+> 递归法
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func sumOfLeftLeaves(root *TreeNode) int {
+    var  res int
+    findLeft(root,&res)
+    return res
+}
+func findLeft(root *TreeNode,res *int){
+    //左节点
+    if root.Left!=nil&&root.Left.Left==nil&&root.Left.Right==nil{
+        *res=*res+root.Left.Val
+    }
+    if root.Left!=nil{
+        findLeft(root.Left,res)
+    }
+    if root.Right!=nil{
+        findLeft(root.Right,res)
+    }
+}
+```
+
+> 迭代法
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func sumOfLeftLeaves(root *TreeNode) int {
+    var  res int
+    queue:=list.New()
+    queue.PushBack(root)
+    for queue.Len()>0{
+        length:=queue.Len()
+        for i:=0;i<length;i++{
+            node:=queue.Remove(queue.Front()).(*TreeNode)
+            if node.Left!=nil&&node.Left.Left==nil&&node.Left.Right==nil{
+                res=res+node.Left.Val
+            }
+            if node.Left!=nil{
+                queue.PushBack(node.Left)
+            }
+            if node.Right!=nil{
+                queue.PushBack(node.Right)
+            }
+        }
+    }
+    return res
+}
+```
+
+
 JavaScript:
 递归版本
 ```javascript
@@ -275,6 +340,7 @@ var sumOfLeftLeaves = function(root) {
 
 
 
+
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)

problems/0513.找树左下角的值.md

@@ -298,6 +298,80 @@ class Solution:
 ```
 Go：
 
+> 递归法
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+ var maxDeep int // 全局变量 深度
+ var  value  int //全局变量 最终值
+func findBottomLeftValue(root *TreeNode) int {
+     if root.Left==nil&&root.Right==nil{//需要提前判断一下（不要这个if的话提交结果会出错，但执行代码不会。防止这种情况出现，故先判断是否只有一个节点）
+         return root.Val
+     }
+    findLeftValue (root,maxDeep)
+    return value
+}
+func findLeftValue (root *TreeNode,deep int){
+     //最左边的值在左边
+     if root.Left==nil&&root.Right==nil{
+         if deep>maxDeep{
+             value=root.Val
+             maxDeep=deep
+         }
+     }
+    //递归
+    if root.Left!=nil{
+        deep++
+        findLeftValue(root.Left,deep)
+        deep--//回溯
+    }
+    if root.Right!=nil{
+        deep++
+        findLeftValue(root.Right,deep)
+        deep--//回溯
+    }
+}
+```
+
+> 迭代法
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func findBottomLeftValue(root *TreeNode) int {
+    queue:=list.New()
+    var gradation int
+    queue.PushBack(root)
+    for queue.Len()>0{
+        length:=queue.Len()
+        for i:=0;i<length;i++{
+            node:=queue.Remove(queue.Front()).(*TreeNode)
+            if i==0{gradation=node.Val}
+            if node.Left!=nil{
+                queue.PushBack(node.Left)
+            }
+            if node.Right!=nil{
+                queue.PushBack(node.Right)
+            }
+        }
+    }
+    return gradation
+}
+```
+
 JavaScript:
 1. 递归版本
 ```javascript

problems/背包理论基础01背包-1.md

@@ -268,7 +268,7 @@ int main() {
 Java：
 
 ```java
-		public static void main(String[] args) {
+    public static void main(String[] args) {
         int[] weight = {1, 3, 4};
         int[] value = {15, 20, 30};
         int bagSize = 4;
@@ -307,6 +307,41 @@ Java：
 
 
 Python：
+```python
+def test_2_wei_bag_problem1(bag_size, weight, value) -> int: 
+	rows, cols = len(weight), bag_size + 1
+	dp = [[0 for _ in range(cols)] for _ in range(rows)]
+	res = 0
+    
+	# 初始化dp数组. 
+	for i in range(rows): 
+		dp[i][0] = 0
+	first_item_weight, first_item_value = weight[0], value[0]
+	for j in range(1, cols): 	
+		if first_item_weight <= j: 
+			dp[0][j] = first_item_value
+
+	# 更新dp数组: 先遍历物品, 再遍历背包. 
+	for i in range(1, len(weight)): 
+		cur_weight, cur_val = weight[i], value[i]
+		for j in range(1, cols): 
+			if cur_weight > j: # 说明背包装不下当前物品. 
+				dp[i][j] = dp[i - 1][j] # 所以不装当前物品. 
+			else: 
+				# 定义dp数组: dp[i][j] 前i个物品里，放进容量为j的背包，价值总和最大是多少。
+				dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - cur_weight]+ cur_val)
+				if dp[i][j] > res: 
+					res = dp[i][j]
+
+	print(dp)
+
+
+if __name__ == "__main__": 
+	bag_size = 4
+	weight = [1, 3, 4]
+	value = [15, 20, 30]
+	test_2_wei_bag_problem1(bag_size, weight, value)
+```
 
 
 Go：