Merge branch 'master' of github.com:youngyangyang04/leetcode-master

Author: youngyangyang04

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 

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

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)
-
-    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]
+        #在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):
+        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:

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

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");
         }
     }
 ```

problems/背包问题理论基础完全背包.md

@@ -94,7 +94,7 @@ dp状态图如下：
 
 看了这两个图，大家就会理解，完全背包中，两个for循环的先后循序，都不影响计算dp[j]所需要的值（这个值就是下标j之前所对应的dp[j]）。
 
-先遍历被背包在遍历物品，代码如下：
+先遍历背包在遍历物品，代码如下：
 
 ```CPP
 // 先遍历背包，再遍历物品