diff --git a/problems/0070.爬楼梯.md b/problems/0070.爬楼梯.md index 7f47a991..da19ea0e 100644 --- a/problems/0070.爬楼梯.md +++ b/problems/0070.爬楼梯.md @@ -256,16 +256,28 @@ public int climbStairs(int n) { ### Python ```python +# 空间复杂度为O(n)版本 class Solution: def climbStairs(self, n: int) -> int: - # dp[i]表示爬到第i级楼梯的种数， (1, 2) (2, 1)是两种不同的类型 - dp = [0] * (n + 1) - dp[0] = 1 - for i in range(n+1): - for j in range(1, 3): - if i>=j: - dp[i] += dp[i-j] - return dp[-1] + # dp[i] 为第 i 阶楼梯有多少种方法爬到楼顶 + dp=[0]*(n+1) + dp[0]=1 + dp[1]=1 + for i in range(2,n+1): + dp[i]=dp[i-1]+dp[i-2] + return dp[n] + +# 空间复杂度为O(1)版本 +class Solution: + def climbStairs(self, n: int) -> int: + dp=[0]*(n+1) + dp[0]=1 + dp[1]=1 + for i in range(2,n+1): + tmp=dp[0]+dp[1] + dp[0]=dp[1] + dp[1]=tmp + return dp[1] ``` ### Go diff --git a/problems/0106.从中序与后序遍历序列构造二叉树.md b/problems/0106.从中序与后序遍历序列构造二叉树.md index 40d75983..3e4211fb 100644 --- a/problems/0106.从中序与后序遍历序列构造二叉树.md +++ b/problems/0106.从中序与后序遍历序列构造二叉树.md @@ -814,7 +814,114 @@ var buildTree = function(preorder, inorder) { }; ``` +## TypeScript + +> 106.从中序与后序遍历序列构造二叉树 + +**创建新数组:** + +```typescript +function buildTree(inorder: number[], postorder: number[]): TreeNode | null { + if (postorder.length === 0) return null; + const rootVal: number = postorder.pop()!; + const rootValIndex: number = inorder.indexOf(rootVal); + const rootNode: TreeNode = new TreeNode(rootVal); + rootNode.left = buildTree(inorder.slice(0, rootValIndex), postorder.slice(0, rootValIndex)); + rootNode.right = buildTree(inorder.slice(rootValIndex + 1), postorder.slice(rootValIndex)); + return rootNode; +}; +``` + +**使用数组索引:** + +```typescript +function buildTree(inorder: number[], postorder: number[]): TreeNode | null { + function recur( + inorder: number[], postorder: number[], + inBegin: number, inEnd: number, + postBegin: number, postEnd: number + ): TreeNode | null { + if (postBegin === postEnd) return null; + const rootVal: number = postorder[postEnd - 1]!; + const rootValIndex: number = inorder.indexOf(rootVal, inBegin); + const rootNode: TreeNode = new TreeNode(rootVal); + + const leftInorderBegin: number = inBegin; + const leftInorderEnd: number = rootValIndex; + const rightInorderBegin: number = rootValIndex + 1; + const rightInorderEnd: number = inEnd; + + const leftPostorderBegin: number = postBegin; + const leftPostorderEnd: number = postBegin + rootValIndex - inBegin; + const rightPostorderBegin: number = leftPostorderEnd; + const rightPostorderEnd: number = postEnd - 1; + + rootNode.left = recur( + inorder, postorder, + leftInorderBegin, leftInorderEnd, + leftPostorderBegin, leftPostorderEnd + ); + rootNode.right = recur( + inorder, postorder, + rightInorderBegin, rightInorderEnd, + rightPostorderBegin, rightPostorderEnd + ); + return rootNode; + } + return recur(inorder, postorder, 0, inorder.length, 0, inorder.length); +}; +``` + +> 105.从前序与中序遍历序列构造二叉树 + +**新建数组：** + +```typescript +function buildTree(preorder: number[], inorder: number[]): TreeNode | null { + if (preorder.length === 0) return null; + const rootVal: number = preorder[0]; + const rootNode: TreeNode = new TreeNode(rootVal); + const rootValIndex: number = inorder.indexOf(rootVal); + rootNode.left = buildTree(preorder.slice(1, rootValIndex + 1), inorder.slice(0, rootValIndex)); + rootNode.right = buildTree(preorder.slice(rootValIndex + 1), inorder.slice(rootValIndex + 1)); + return rootNode; +}; +``` + +**使用数组索引:** + +```typescript +function buildTree(preorder: number[], inorder: number[]): TreeNode | null { + function recur( + preorder: number[], inorder: number[], + preBegin: number, preEnd: number, + inBegin: number, inEnd: number + ): TreeNode | null { + if (preBegin === preEnd) return null; + const rootVal: number = preorder[preBegin]; + const rootNode: TreeNode = new TreeNode(rootVal); + const rootValIndex: number = inorder.indexOf(rootVal, inBegin); + + const leftPreBegin: number = preBegin + 1; + const leftPreEnd: number = preBegin + rootValIndex - inBegin + 1; + const leftInBegin: number = inBegin; + const leftInEnd: number = rootValIndex; + + const rightPreBegin: number = leftPreEnd; + const rightPreEnd: number = preEnd; + const rightInBegin: number = rootValIndex + 1; + const rightInEnd: number = inEnd; + + rootNode.left = recur(preorder, inorder, leftPreBegin, leftPreEnd, leftInBegin, leftInEnd); + rootNode.right = recur(preorder, inorder, rightPreBegin, rightPreEnd, rightInBegin, rightInEnd); + return rootNode; + }; + return recur(preorder, inorder, 0, preorder.length, 0, inorder.length); +}; +``` + ## C + 106 从中序与后序遍历序列构造二叉树 ```c diff --git a/problems/0213.打家劫舍II.md b/problems/0213.打家劫舍II.md index b6c2d080..8e569e46 100644 --- a/problems/0213.打家劫舍II.md +++ b/problems/0213.打家劫舍II.md @@ -123,22 +123,24 @@ Python： ```Python class Solution: def rob(self, nums: List[int]) -> int: - if (n := len(nums)) == 0: - return 0 - if n == 1: - return nums[0] - result1 = self.robRange(nums, 0, n - 2) - result2 = self.robRange(nums, 1, n - 1) - return max(result1 , result2) + #在198入门级的打家劫舍问题上分两种情况考虑 + #一是不偷第一间房，二是不偷最后一间房 + if len(nums)==1:#题目中提示nums.length>=1,所以不需要考虑len(nums)==0的情况 + return nums[0] + val1=self.roblist(nums[1:])#不偷第一间房 + val2=self.roblist(nums[:-1])#不偷最后一间房 + return max(val1,val2) - def robRange(self, nums: List[int], start: int, end: int) -> int: - if end == start: return nums[start] - dp = [0] * len(nums) - dp[start] = nums[start] - dp[start + 1] = max(nums[start], nums[start + 1]) - for i in range(start + 2, end + 1): - dp[i] = max(dp[i -2] + nums[i], dp[i - 1]) - return dp[end] + def robRange(self,nums): + l=len(nums) + dp=[0]*l + dp[0]=nums[0] + for i in range(1,l): + if i==1: + dp[i]=max(dp[i-1],nums[i]) + else: + dp[i]=max(dp[i-1],dp[i-2]+nums[i]) + return dp[-1] ``` javascipt: diff --git a/problems/0654.最大二叉树.md b/problems/0654.最大二叉树.md index 44c74f89..1c73354b 100644 --- a/problems/0654.最大二叉树.md +++ b/problems/0654.最大二叉树.md @@ -371,7 +371,56 @@ var constructMaximumBinaryTree = function (nums) { }; ``` +## TypeScript + +> 新建数组法： + +```typescript +function constructMaximumBinaryTree(nums: number[]): TreeNode | null { + if (nums.length === 0) return null; + let maxIndex: number = 0; + let maxVal: number = nums[0]; + for (let i = 1, length = nums.length; i < length; i++) { + if (nums[i] > maxVal) { + maxIndex = i; + maxVal = nums[i]; + } + } + const rootNode: TreeNode = new TreeNode(maxVal); + rootNode.left = constructMaximumBinaryTree(nums.slice(0, maxIndex)); + rootNode.right = constructMaximumBinaryTree(nums.slice(maxIndex + 1)); + return rootNode; +}; +``` + +> 使用数组索引法： + +```typescript +function constructMaximumBinaryTree(nums: number[]): TreeNode | null { + // 左闭右开区间[begin, end) + function recur(nums: number[], begin: number, end: number): TreeNode | null { + if (begin === end) return null; + let maxIndex: number = begin; + let maxVal: number = nums[begin]; + for (let i = begin + 1; i < end; i++) { + if (nums[i] > maxVal) { + maxIndex = i; + maxVal = nums[i]; + } + } + const rootNode: TreeNode = new TreeNode(maxVal); + rootNode.left = recur(nums, begin, maxIndex); + rootNode.right = recur(nums, maxIndex + 1, end); + return rootNode; + } + return recur(nums, 0, nums.length); +}; +``` + + + ## C + ```c struct TreeNode* traversal(int* nums, int left, int right) { //若左边界大于右边界，返回NULL diff --git a/problems/背包理论基础01背包-1.md b/problems/背包理论基础01背包-1.md index 6ff32017..fe940b4c 100644 --- a/problems/背包理论基础01背包-1.md +++ b/problems/背包理论基础01背包-1.md @@ -271,7 +271,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; @@ -292,16 +292,16 @@ int main() { if (j < weight[i - 1]){ dp[i][j] = dp[i - 1][j]; }else{ - dp[i][j] = math.max(dp[i - 1][j], dp[i - 1][j - weight[i - 1]] + value[i - 1]); + dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - weight[i - 1]] + value[i - 1]); } } } //打印dp数组 for (int i = 0; i <= wlen; i++){ for (int j = 0; j <= bagsize; j++){ - system.out.print(dp[i][j] + " "); + System.out.print(dp[i][j] + " "); } - system.out.print("\n"); + System.out.print("\n"); } } ``` diff --git a/problems/背包问题理论基础完全背包.md b/problems/背包问题理论基础完全背包.md index 7abaf160..faa1dc46 100644 --- a/problems/背包问题理论基础完全背包.md +++ b/problems/背包问题理论基础完全背包.md @@ -94,7 +94,7 @@ dp状态图如下： 看了这两个图，大家就会理解，完全背包中，两个for循环的先后循序，都不影响计算dp[j]所需要的值（这个值就是下标j之前所对应的dp[j]）。 -先遍历被背包在遍历物品，代码如下： +先遍历背包在遍历物品，代码如下： ```CPP // 先遍历背包，再遍历物品