diff --git a/problems/0024.两两交换链表中的节点.md b/problems/0024.两两交换链表中的节点.md index cd8743a7..8d6a394d 100644 --- a/problems/0024.两两交换链表中的节点.md +++ b/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 diff --git a/problems/0077.组合.md b/problems/0077.组合.md index 783f7da7..0b289a40 100644 --- a/problems/0077.组合.md +++ b/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) diff --git a/problems/0077.组合优化.md b/problems/0077.组合优化.md index 3f6c2fce..31acf4a5 100644 --- a/problems/0077.组合优化.md +++ b/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] + } +} +``` diff --git a/problems/0101.对称二叉树.md b/problems/0101.对称二叉树.md index 5ce13e2e..d8797d30 100644 --- a/problems/0101.对称二叉树.md +++ b/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; +}; +``` + ----------------------- diff --git a/problems/0106.从中序与后序遍历序列构造二叉树.md b/problems/0106.从中序与后序遍历序列构造二叉树.md index 49e7f828..ba2d46a1 100644 --- a/problems/0106.从中序与后序遍历序列构造二叉树.md +++ b/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: diff --git a/problems/0112.路径总和.md b/problems/0112.路径总和.md index 65f0fa62..b4a3f38b 100644 --- a/problems/0112.路径总和.md +++ b/problems/0112.路径总和.md @@ -347,6 +347,42 @@ class Solution { } ``` +0113.路径总和-ii + +```java +class Solution { + public List> pathSum(TreeNode root, int targetSum) { + List> res = new ArrayList<>(); + if (root == null) return res; // 非空判断 + + List path = new LinkedList<>(); + preorderDFS(root, targetSum, res, path); + return res; + } + + public void preorderDFS(TreeNode root, int targetSum, List> res, List 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.路径总和 diff --git a/problems/0344.反转字符串.md b/problems/0344.反转字符串.md index 59688e44..1b86e847 100644 --- a/problems/0344.反转字符串.md +++ b/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; +}; +``` + + + diff --git a/problems/0541.反转字符串II.md b/problems/0541.反转字符串II.md index 8e456322..db53caf7 100644 --- a/problems/0541.反转字符串II.md +++ b/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(""); +}; + +``` diff --git a/problems/0968.监控二叉树.md b/problems/0968.监控二叉树.md index 24695da9..8f1a3fdb 100644 --- a/problems/0968.监控二叉树.md +++ b/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：