diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md index 1fb9b633..1a92d42f 100644 --- a/problems/0102.二叉树的层序遍历.md +++ b/problems/0102.二叉树的层序遍历.md @@ -246,7 +246,35 @@ var levelOrder = function(root) { ``` +TypeScript： + +```typescript +function levelOrder(root: TreeNode | null): number[][] { + let helperQueue: TreeNode[] = []; + let res: number[][] = []; + let tempArr: number[] = []; + if (root !== null) helperQueue.push(root); + let curNode: TreeNode; + while (helperQueue.length > 0) { + for (let i = 0, length = helperQueue.length; i < length; i++) { + curNode = helperQueue.shift()!; + tempArr.push(curNode.val); + if (curNode.left !== null) { + helperQueue.push(curNode.left); + } + if (curNode.right !== null) { + helperQueue.push(curNode.right); + } + } + res.push(tempArr); + tempArr = []; + } + return res; +}; +``` + Swift: + ```swift func levelOrder(_ root: TreeNode?) -> [[Int]] { var res = [[Int]]() @@ -454,7 +482,31 @@ var levelOrderBottom = function(root) { }; ``` +TypeScript: + +```typescript +function levelOrderBottom(root: TreeNode | null): number[][] { + let helperQueue: TreeNode[] = []; + let resArr: number[][] = []; + let tempArr: number[] = []; + let tempNode: TreeNode; + if (root !== null) helperQueue.push(root); + while (helperQueue.length > 0) { + for (let i = 0, length = helperQueue.length; i < length; i++) { + tempNode = helperQueue.shift()!; + tempArr.push(tempNode.val); + if (tempNode.left !== null) helperQueue.push(tempNode.left); + if (tempNode.right !== null) helperQueue.push(tempNode.right); + } + resArr.push(tempArr); + tempArr = []; + } + return resArr.reverse(); +}; +``` + Swift: + ```swift func levelOrderBottom(_ root: TreeNode?) -> [[Int]] { var res = [[Int]]() @@ -657,7 +709,28 @@ var rightSideView = function(root) { }; ``` +TypeScript： + +```typescript +function rightSideView(root: TreeNode | null): number[] { + let helperQueue: TreeNode[] = []; + let resArr: number[] = []; + let tempNode: TreeNode; + if (root !== null) helperQueue.push(root); + while (helperQueue.length > 0) { + for (let i = 0, length = helperQueue.length; i < length; i++) { + tempNode = helperQueue.shift()!; + if (i === length - 1) resArr.push(tempNode.val); + if (tempNode.left !== null) helperQueue.push(tempNode.left); + if (tempNode.right !== null) helperQueue.push(tempNode.right); + } + } + return resArr; +}; +``` + Swift: + ```swift func rightSideView(_ root: TreeNode?) -> [Int] { var res = [Int]() @@ -868,7 +941,32 @@ var averageOfLevels = function(root) { }; ``` +TypeScript： + +```typescript +function averageOfLevels(root: TreeNode | null): number[] { + let helperQueue: TreeNode[] = []; + let resArr: number[] = []; + let total: number = 0; + let tempNode: TreeNode; + if (root !== null) helperQueue.push(root); + while (helperQueue.length > 0) { + let length = helperQueue.length; + for (let i = 0; i < length; i++) { + tempNode = helperQueue.shift()!; + total += tempNode.val; + if (tempNode.left) helperQueue.push(tempNode.left); + if (tempNode.right) helperQueue.push(tempNode.right); + } + resArr.push(total / length); + total = 0; + } + return resArr; +}; +``` + Swift: + ```swift func averageOfLevels(_ root: TreeNode?) -> [Double] { var res = [Double]() @@ -1092,7 +1190,30 @@ var levelOrder = function(root) { }; ``` +TypeScript: + +```typescript +function levelOrder(root: Node | null): number[][] { + let helperQueue: Node[] = []; + let resArr: number[][] = []; + let tempArr: number[] = []; + if (root !== null) helperQueue.push(root); + let curNode: Node; + while (helperQueue.length > 0) { + for (let i = 0, length = helperQueue.length; i < length; i++) { + curNode = helperQueue.shift()!; + tempArr.push(curNode.val); + helperQueue.push(...curNode.children); + } + resArr.push(tempArr); + tempArr = []; + } + return resArr; +}; +``` + Swift: + ```swift func levelOrder(_ root: Node?) -> [[Int]] { var res = [[Int]]() @@ -1272,7 +1393,34 @@ var largestValues = function(root) { }; ``` +TypeScript: + +```typescript +function largestValues(root: TreeNode | null): number[] { + let helperQueue: TreeNode[] = []; + let resArr: number[] = []; + let tempNode: TreeNode; + let max: number = 0; + if (root !== null) helperQueue.push(root); + while (helperQueue.length > 0) { + for (let i = 0, length = helperQueue.length; i < length; i++) { + tempNode = helperQueue.shift()!; + if (i === 0) { + max = tempNode.val; + } else { + max = max > tempNode.val ? max : tempNode.val; + } + if (tempNode.left) helperQueue.push(tempNode.left); + if (tempNode.right) helperQueue.push(tempNode.right); + } + resArr.push(max); + } + return resArr; +}; +``` + Swift: + ```swift func largestValues(_ root: TreeNode?) -> [Int] { var res = [Int]() @@ -1463,6 +1611,31 @@ var connect = function(root) { }; ``` +TypeScript: + +```typescript +function connect(root: Node | null): Node | null { + let helperQueue: Node[] = []; + let preNode: Node, curNode: Node; + if (root !== null) helperQueue.push(root); + while (helperQueue.length > 0) { + for (let i = 0, length = helperQueue.length; i < length; i++) { + if (i === 0) { + preNode = helperQueue.shift()!; + } else { + curNode = helperQueue.shift()!; + preNode.next = curNode; + preNode = curNode; + } + if (preNode.left) helperQueue.push(preNode.left); + if (preNode.right) helperQueue.push(preNode.right); + } + preNode.next = null; + } + return root; +}; +``` + go: ```GO @@ -1689,6 +1862,31 @@ var connect = function(root) { return root; }; ``` +TypeScript: + +```typescript +function connect(root: Node | null): Node | null { + let helperQueue: Node[] = []; + let preNode: Node, curNode: Node; + if (root !== null) helperQueue.push(root); + while (helperQueue.length > 0) { + for (let i = 0, length = helperQueue.length; i < length; i++) { + if (i === 0) { + preNode = helperQueue.shift()!; + } else { + curNode = helperQueue.shift()!; + preNode.next = curNode; + preNode = curNode; + } + if (preNode.left) helperQueue.push(preNode.left); + if (preNode.right) helperQueue.push(preNode.right); + } + preNode.next = null; + } + return root; +}; +``` + go: ```GO @@ -1933,7 +2131,28 @@ var maxDepth = function(root) { }; ``` +TypeScript: + +```typescript +function maxDepth(root: TreeNode | null): number { + let helperQueue: TreeNode[] = []; + let resDepth: number = 0; + let tempNode: TreeNode; + if (root !== null) helperQueue.push(root); + while (helperQueue.length > 0) { + resDepth++; + for (let i = 0, length = helperQueue.length; i < length; i++) { + tempNode = helperQueue.shift()!; + if (tempNode.left) helperQueue.push(tempNode.left); + if (tempNode.right) helperQueue.push(tempNode.right); + } + } + return resDepth; +}; +``` + Swift: + ```swift func maxDepth(_ root: TreeNode?) -> Int { guard let root = root else { @@ -2130,7 +2349,29 @@ var minDepth = function(root) { }; ``` +TypeScript: + +```typescript +function minDepth(root: TreeNode | null): number { + let helperQueue: TreeNode[] = []; + let resMin: number = 0; + let tempNode: TreeNode; + if (root !== null) helperQueue.push(root); + while (helperQueue.length > 0) { + resMin++; + for (let i = 0, length = helperQueue.length; i < length; i++) { + tempNode = helperQueue.shift()!; + if (tempNode.left === null && tempNode.right === null) return resMin; + if (tempNode.left !== null) helperQueue.push(tempNode.left); + if (tempNode.right !== null) helperQueue.push(tempNode.right); + } + } + return resMin; +}; +``` + Swift： + ```swift func minDepth(_ root: TreeNode?) -> Int { guard let root = root else { diff --git a/problems/0112.路径总和.md b/problems/0112.路径总和.md index 5ec8ffd0..a884b278 100644 --- a/problems/0112.路径总和.md +++ b/problems/0112.路径总和.md @@ -531,82 +531,63 @@ class solution: ```go //递归法 /** - * definition for a binary tree node. - * type treenode struct { - * val int - * left *treenode - * right *treenode + * 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 +func hasPathSum(root *TreeNode, targetSum int) bool { + if root == nil { + return false } - 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) + + targetSum -= root.Val // 将targetSum在遍历每层的时候都减去本层节点的值 + if root.Left == nil && root.Right == nil && targetSum == 0 { // 如果剩余的targetSum为0, 则正好就是符合的结果 + return true } + return hasPathSum(root.Left, targetSum) || hasPathSum(root.Right, targetSum) // 否则递归找 } ``` -113 递归法 +113. 路径总和 II ```go /** - * definition for a binary tree node. - * type treenode struct { - * val int - * left *treenode - * right *treenode + * 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) +func pathSum(root *TreeNode, targetSum int) [][]int { + result := make([][]int, 0) + traverse(root, &result, new([]int), targetSum) 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) - } + +func traverse(node *TreeNode, result *[][]int, currPath *[]int, targetSum int) { + if node == nil { // 这个判空也可以挪到递归遍历左右子树时去判断 + return } - 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]//回溯 + + targetSum -= node.Val // 将targetSum在遍历每层的时候都减去本层节点的值 + *currPath = append(*currPath, node.Val) // 把当前节点放到路径记录里 + + if node.Left == nil && node.Right == nil && targetSum == 0 { // 如果剩余的targetSum为0, 则正好就是符合的结果 + // 不能直接将currPath放到result里面, 因为currPath是共享的, 每次遍历子树时都会被修改 + pathCopy := make([]int, len(*currPath)) + for i, element := range *currPath { + pathCopy[i] = element + } + *result = append(*result, pathCopy) // 将副本放到结果集里 } + + traverse(node.Left, result, currPath, targetSum) + traverse(node.Right, result, currPath, targetSum) + *currPath = (*currPath)[:len(*currPath)-1] // 当前节点遍历完成, 从路径记录里删除掉 } ``` diff --git a/problems/0416.分割等和子集.md b/problems/0416.分割等和子集.md index 45b8b416..9da1f8d5 100644 --- a/problems/0416.分割等和子集.md +++ b/problems/0416.分割等和子集.md @@ -210,6 +210,45 @@ class Solution { } ``` +二维数组版本（易于理解）： +```Java +class Solution { + public boolean canPartition(int[] nums) { + int sum = 0; + for (int i = 0; i < nums.length; i++) { + sum += nums[i]; + } + + if (sum % 2 == 1) + return false; + int target = sum / 2; + + //dp[i][j]代表可装物品为0-i，背包容量为j的情况下，背包内容量的最大价值 + int[][] dp = new int[nums.length][target + 1]; + + //初始化,dp[0][j]的最大价值nums[0](if j > weight[i]) + //dp[i][0]均为0，不用初始化 + for (int j = nums[0]; j <= target; j++) { + dp[0][j] = nums[0]; + } + + //遍历物品，遍历背包 + //递推公式: + for (int i = 1; i < nums.length; i++) { + for (int j = 0; j <= target; j++) { + //背包容量可以容纳nums[i] + if (j >= nums[i]) { + dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - nums[i]] + nums[i]); + } else { + dp[i][j] = dp[i - 1][j]; + } + } + } + + return dp[nums.length - 1][target] == target; + } +} +``` Python： ```python class Solution: diff --git a/problems/1049.最后一块石头的重量II.md b/problems/1049.最后一块石头的重量II.md index d64e7e56..7b67b1ac 100644 --- a/problems/1049.最后一块石头的重量II.md +++ b/problems/1049.最后一块石头的重量II.md @@ -153,6 +153,8 @@ public: Java： + +一维数组版本 ```Java class Solution { public int lastStoneWeightII(int[] stones) { @@ -173,6 +175,41 @@ class Solution { return sum - 2 * dp[target]; } } +``` +二维数组版本（便于理解） +```Java +class Solution { + public int lastStoneWeightII(int[] stones) { + int sum = 0; + for (int s : stones) { + sum += s; + } + + int target = sum / 2; + //初始化，dp[i][j]为可以放0-i物品，背包容量为j的情况下背包中的最大价值 + int[][] dp = new int[stones.length][target + 1]; + //dp[i][0]默认初始化为0 + //dp[0][j]取决于stones[0] + for (int j = stones[0]; j <= target; j++) { + dp[0][j] = stones[0]; + } + + for (int i = 1; i < stones.length; i++) { + for (int j = 1; j <= target; j++) {//注意是等于 + if (j >= stones[i]) { + //不放:dp[i - 1][j] 放:dp[i - 1][j - stones[i]] + stones[i] + dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - stones[i]] + stones[i]); + } else { + dp[i][j] = dp[i - 1][j]; + } + } + } + + System.out.println(dp[stones.length - 1][target]); + return (sum - dp[stones.length - 1][target]) - dp[stones.length - 1][target]; + } +} + ``` Python： diff --git a/problems/二叉树的统一迭代法.md b/problems/二叉树的统一迭代法.md index 2ff84817..f6edf586 100644 --- a/problems/二叉树的统一迭代法.md +++ b/problems/二叉树的统一迭代法.md @@ -522,7 +522,75 @@ var postorderTraversal = function(root, res = []) { ``` +TypeScript： +```typescript +// 前序遍历（迭代法） +function preorderTraversal(root: TreeNode | null): number[] { + let helperStack: (TreeNode | null)[] = []; + let res: number[] = []; + let curNode: TreeNode | null; + if (root === null) return res; + helperStack.push(root); + while (helperStack.length > 0) { + curNode = helperStack.pop()!; + if (curNode !== null) { + if (curNode.right !== null) helperStack.push(curNode.right); + helperStack.push(curNode); + helperStack.push(null); + if (curNode.left !== null) helperStack.push(curNode.left); + } else { + curNode = helperStack.pop()!; + res.push(curNode.val); + } + } + return res; +}; + +// 中序遍历（迭代法） +function inorderTraversal(root: TreeNode | null): number[] { + let helperStack: (TreeNode | null)[] = []; + let res: number[] = []; + let curNode: TreeNode | null; + if (root === null) return res; + helperStack.push(root); + while (helperStack.length > 0) { + curNode = helperStack.pop()!; + if (curNode !== null) { + if (curNode.right !== null) helperStack.push(curNode.right); + helperStack.push(curNode); + helperStack.push(null); + if (curNode.left !== null) helperStack.push(curNode.left); + } else { + curNode = helperStack.pop()!; + res.push(curNode.val); + } + } + return res; +}; + +// 后序遍历（迭代法） +function postorderTraversal(root: TreeNode | null): number[] { + let helperStack: (TreeNode | null)[] = []; + let res: number[] = []; + let curNode: TreeNode | null; + if (root === null) return res; + helperStack.push(root); + while (helperStack.length > 0) { + curNode = helperStack.pop()!; + if (curNode !== null) { + if (curNode.right !== null) helperStack.push(curNode.right); + helperStack.push(curNode); + helperStack.push(null); + if (curNode.left !== null) helperStack.push(curNode.left); + } else { + curNode = helperStack.pop()!; + res.push(curNode.val); + } + } + return res; +}; +``` -----------------------