Merge branch 'youngyangyang04:master' into master

problems/0024.两两交换链表中的节点.md

@@ -131,6 +131,27 @@ class Solution {
 Python：
 
 Go：
+```go
+func swapPairs(head *ListNode) *ListNode {
+    dummy := &ListNode{
+        Next: head,
+    }
+    //head=list[i]
+    //pre=list[i-1]
+    pre := dummy 
+    for head != nil && head.Next != nil {
+        pre.Next = head.Next
+        next := head.Next.Next
+        head.Next.Next = head
+        head.Next = next
+        //pre=list[(i+2)-1]
+        pre = head 
+        //head=list[(i+2)]
+        head = next
+    }
+    return dummy.Next
+}
+```
 
 Javascript:
 ```javascript

problems/0077.组合.md

@@ -370,23 +370,21 @@ class Solution {
 
 
 Python：
-```python
+```python3
 class Solution:
-    result: List[List[int]] = []
-    path: List[int] = []
     def combine(self, n: int, k: int) -> List[List[int]]:
-      self.result = []
-      self.combineHelper(n, k, 1)
-      return self.result
-
-    def combineHelper(self, n: int, k: int, startIndex: int):
-      if  (l := len(self.path)) == k:
-        self.result.append(self.path.copy())
-        return
-      for i in range(startIndex, n - (k - l) + 2):
-        self.path.append(i)
-        self.combineHelper(n, k, i + 1)
-        self.path.pop()
+        res=[]  #存放符合条件结果的集合
+        path=[]  #用来存放符合条件结果
+        def backtrack(n,k,startIndex):
+            if len(path) == k:
+                res.append(path[:])
+                return 
+            for i in range(startIndex,n+1):
+                path.append(i)  #处理节点 
+                backtrack(n,k,i+1)  #递归
+                path.pop()  #回溯，撤销处理的节点
+        backtrack(n,k,1)
+        return res
 ```
 javascript
 ```javascript
@@ -438,8 +436,6 @@ func backtrack(n,k,start int,track []int){
 ```
 
 
-
-
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)

problems/0077.组合优化.md

@@ -176,9 +176,49 @@ class Solution {
 ```
 
 Python：
-
-
+```python3
+class Solution:
+    def combine(self, n: int, k: int) -> List[List[int]]:
+        res=[]  #存放符合条件结果的集合
+        path=[]  #用来存放符合条件结果
+        def backtrack(n,k,startIndex):
+            if len(path) == k:
+                res.append(path[:])
+            return 
+            for i in range(startIndex,n-(k-len(path))+2):  #优化的地方
+                path.append(i)  #处理节点 
+                backtrack(n,k,i+1)  #递归
+                path.pop()  #回溯，撤销处理的节点
+    backtrack(n,k,1)
+    return res
+```
 Go：
+```Go
+var res [][]int 
+func combine(n int, k int) [][]int {
+   res=[][]int{}
+   if n <= 0 || k <= 0 || k > n {
+		return res
+	}
+    backtrack(n, k, 1, []int{})
+	return res
+}
+func backtrack(n,k,start int,track []int){
+    if len(track)==k{
+        temp:=make([]int,k)
+        copy(temp,track)
+        res=append(res,temp)
+    }
+    if len(track)+n-start+1 < k {
+			return
+		}
+    for i:=start;i<=n;i++{ 
+        track=append(track,i)
+        backtrack(n,k,i+1,track)
+        track=track[:len(track)-1]
+    }
+}
+```
 
 
 

problems/0101.对称二叉树.md

@@ -379,6 +379,90 @@ const check = (leftPtr, rightPtr) => {
     return leftPtr.val === rightPtr.val && check(leftPtr.left, rightPtr.right) && check(leftPtr.right, rightPtr.left)
 }
 ```
+JavaScript:
+
+递归判断是否为对称二叉树：
+```javascript
+var isSymmetric = function(root) {
+    //使用递归遍历左右子树 递归三部曲
+    // 1. 确定递归的参数 root.left root.right和返回值true false 
+    const compareNode=function(left,right){
+        //2. 确定终止条件 空的情况
+        if(left===null&&right!==null||left!==null&&right===null){
+            return false;
+        }else if(left===null&&right===null){
+            return true;
+        }else if(left.val!==right.val){
+            return false;
+        }
+        //3. 确定单层递归逻辑
+        let outSide=compareNode(left.left,right.right);
+        let inSide=compareNode(left.right,right.left);
+        return outSide&&inSide;
+    }
+    if(root===null){
+        return true;
+    }
+    return compareNode(root.left,root.right);
+};
+```
+队列实现迭代判断是否为对称二叉树：
+```javascript
+var isSymmetric = function(root) {
+  //迭代方法判断是否是对称二叉树
+  //首先判断root是否为空
+  if(root===null){
+      return true;
+  }
+  let queue=[];
+  queue.push(root.left);
+  queue.push(root.right);
+  while(queue.length){
+      let leftNode=queue.shift();//左节点
+      let rightNode=queue.shift();//右节点
+      if(leftNode===null&&rightNode===null){
+          continue;
+      }
+      if(leftNode===null||rightNode===null||leftNode.val!==rightNode.val){
+          return false;
+      }
+      queue.push(leftNode.left);//左节点左孩子入队
+      queue.push(rightNode.right);//右节点右孩子入队
+      queue.push(leftNode.right);//左节点右孩子入队
+      queue.push(rightNode.left);//右节点左孩子入队
+  }
+  return true;
+};
+```
+栈实现迭代判断是否为对称二叉树：
+```javascript
+var isSymmetric = function(root) {
+  //迭代方法判断是否是对称二叉树
+  //首先判断root是否为空
+  if(root===null){
+      return true;
+  }
+  let stack=[];
+  stack.push(root.left);
+  stack.push(root.right);
+  while(stack.length){
+      let rightNode=stack.pop();//左节点
+      let leftNode=stack.pop();//右节点
+      if(leftNode===null&&rightNode===null){
+          continue;
+      }
+      if(leftNode===null||rightNode===null||leftNode.val!==rightNode.val){
+          return false;
+      }
+      stack.push(leftNode.left);//左节点左孩子入队
+      stack.push(rightNode.right);//右节点右孩子入队
+      stack.push(leftNode.right);//左节点右孩子入队
+      stack.push(rightNode.left);//右节点左孩子入队
+  }
+  return true;
+};
+```
+
 
 
 -----------------------

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

@@ -580,8 +580,10 @@ tree2 的前序遍历是[1 2 3]， 后序遍历是[3 2 1]。
 
 ## 其他语言版本
 
-
 Java：
+
+106.从中序与后序遍历序列构造二叉树
+
 ```java
 class Solution {
     public TreeNode buildTree(int[] inorder, int[] postorder) {
@@ -617,8 +619,43 @@ class Solution {
 }
 ```
 
+105.从前序与中序遍历序列构造二叉树
+
+```java
+class Solution {
+    public TreeNode buildTree(int[] preorder, int[] inorder) {
+        return helper(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1);
+    }
+
+    public TreeNode helper(int[] preorder, int preLeft, int preRight,
+                           int[] inorder, int inLeft, int inRight) {
+        // 递归终止条件
+        if (inLeft > inRight || preLeft > preRight) return null;
+
+        // val 为前序遍历第一个的值，也即是根节点的值
+        // idx 为根据根节点的值来找中序遍历的下标
+        int idx = inLeft, val = preorder[preLeft];
+        TreeNode root = new TreeNode(val);
+        for (int i = inLeft; i <= inRight; i++) {
+            if (inorder[i] == val) {
+                idx = i;
+                break;
+            }
+        }
+
+        // 根据 idx 来递归找左右子树
+        root.left = helper(preorder, preLeft + 1, preLeft + (idx - inLeft),
+                         inorder, inLeft, idx - 1);
+        root.right = helper(preorder, preLeft + (idx - inLeft) + 1, preRight,
+                         inorder, idx + 1, inRight);
+        return root;
+    }
+}
+```
+
 Python：
 105.从前序与中序遍历序列构造二叉树
+
 ```python
 # Definition for a binary tree node.
 # class TreeNode:
@@ -637,6 +674,7 @@ class Solution:
             return root
 ```
 106.从中序与后序遍历序列构造二叉树
+
 ```python
 # Definition for a binary tree node.
 # class TreeNode:

problems/0112.路径总和.md

@@ -347,6 +347,42 @@ class Solution {
 }
 ```
 
+0113.路径总和-ii
+
+```java
+class Solution {
+    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
+        List<List<Integer>> res = new ArrayList<>();
+        if (root == null) return res; // 非空判断
+        
+        List<Integer> path = new LinkedList<>();
+        preorderDFS(root, targetSum, res, path);
+        return res;
+    }
+
+    public void preorderDFS(TreeNode root, int targetSum, List<List<Integer>> res, List<Integer> path) {
+        path.add(root.val);
+        // 遇到了叶子节点
+        if (root.left == null && root.right == null) {
+            // 找到了和为 targetSum 的路径
+            if (targetSum - root.val == 0) {
+                res.add(new ArrayList<>(path));
+            }
+            return; // 如果和不为 targetSum，返回
+        }
+
+        if (root.left != null) {
+            preorderDFS(root.left, targetSum - root.val, res, path);
+            path.remove(path.size() - 1); // 回溯
+        }
+        if (root.right != null) {
+            preorderDFS(root.right, targetSum - root.val, res, path);
+            path.remove(path.size() - 1); // 回溯
+        }
+    }
+}
+```
+
 Python：
 
 0112.路径总和

problems/0344.反转字符串.md

@@ -183,6 +183,26 @@ func reverseString(s []byte)  {
 }
 ```
 
+javaScript:
+
+```js
+/**
+ * @param {character[]} s
+ * @return {void} Do not return anything, modify s in-place instead.
+ */
+var reverseString = function(s) {
+    return s.reverse();
+};
+
+var reverseString = function(s) {
+    let l = -1, r = s.length;
+    while(++l < --r) [s[l], s[r]] = [s[r], s[l]];
+    return s;
+};
+```
+
+
+
 
 
 

problems/0541.反转字符串II.md

@@ -168,6 +168,26 @@ class Solution(object):
 
 Go：
 
+javaScript: 
+
+```js
+
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {string}
+ */
+var reverseStr = function(s, k) {
+    const len = s.length;
+    let resArr = s.split(""); 
+    for(let i = 0; i < len; i += 2 * k) {
+        let l = i - 1, r = i + k > len ? len : i + k;
+        while(++l < --r) [resArr[l], resArr[r]] = [resArr[r], resArr[l]];
+    }
+    return resArr.join("");
+};
+
+```
 
 
 

problems/0968.监控二叉树.md

@@ -346,8 +346,27 @@ class Solution {
 
 
 Python：
-
-
+```python
+class Solution:
+    def minCameraCover(self, root: TreeNode) -> int:
+        result = 0
+        def traversal(cur):
+            nonlocal result
+            if not cur:
+                return 2
+            left = traversal(cur.left)
+            right = traversal(cur.right)
+            if left == 2 and right == 2:
+                return 0
+            elif left == 0 or right == 0:
+                result += 1
+                return 1
+            elif left == 1 or right == 1:
+                return 2
+            else: return -1
+        if traversal(root) == 0: result += 1
+        return result
+```
 Go：