Merge branch 'youngyangyang04:master' into master

Author: jeremy-feng

problems/0001.两数之和.md

@@ -216,6 +216,26 @@ impl Solution {
     }
 }
 ```
+Rust
+
+```
+use std::collections::HashMap;
+ 
+impl Solution {
+    pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
+        let mut hm: HashMap<i32, i32> = HashMap::new();
+        for i in 0..nums.len() {
+            let j = target - nums[i];
+            if hm.contains_key(&j) {
+                return vec![*hm.get(&j).unwrap(), i as i32]
+            } else {
+                hm.insert(nums[i], i as i32);
+            }
+        }
+        vec![-1, -1]
+    }
+}
+```
 
 Javascript
 

problems/0020.有效的括号.md

@@ -135,6 +135,9 @@ public:
 };
 
 ```
+* 时间复杂度: O(n)
+* 空间复杂度: O(n)
+
 技巧性的东西没有固定的学习方法，还是要多看多练，自己灵活运用了。
 
 

problems/0056.合并区间.md

@@ -177,6 +177,34 @@ func max(a, b int) int {
     return b
 }
 ```
+```go
+// 版本2
+func merge(intervals [][]int) [][]int {
+    if len(intervals) == 1 {
+        return intervals
+    }
+    sort.Slice(intervals, func(i, j int) bool {
+        return intervals[i][0] < intervals[j][0]
+    })
+    res := make([][]int, 0)
+    res = append(res, intervals[0])
+    for i := 1; i < len(intervals); i++ {
+        if intervals[i][0] <= res[len(res)-1][1]{
+            res[len(res)-1][1] = max56(res[len(res)-1][1],intervals[i][1])
+        } else {
+            res = append(res, intervals[i])
+        }
+    }
+    return res
+}
+func max56(a, b int) int {
+    if a > b {
+        return a
+    }
+    return b
+}
+```
+
 
 ### Javascript 
 ```javascript

problems/0070.爬楼梯.md

@@ -72,7 +72,7 @@ dp[i]： 爬到第i层楼梯，有dp[i]种方法
 
 3. dp数组如何初始化
 
-再回顾一下dp[i]的定义：爬到第i层楼梯，有dp[i]中方法。
+再回顾一下dp[i]的定义：爬到第i层楼梯，有dp[i]种方法。
 
 那么i为0，dp[i]应该是多少呢，这个可以有很多解释，但基本都是直接奔着答案去解释的。
 

problems/0150.逆波兰表达式求值.md

@@ -113,6 +113,9 @@ public:
 };
 
 ```
+* 时间复杂度: O(n)
+* 空间复杂度: O(n)
+
 
 ## 题外话
 

problems/0225.用队列实现栈.md

@@ -111,6 +111,8 @@ public:
     }
 };
 ```
+* 时间复杂度: push为O(n)，其他为O(1)
+* 空间复杂度: O(n)
 
 # 优化
 
@@ -156,6 +158,9 @@ public:
     }
 };
 ```
+* 时间复杂度: push为O(n)，其他为O(1)
+* 空间复杂度: O(n)
+
 
 # 其他语言版本
 

problems/0232.用栈实现队列.md

@@ -112,6 +112,10 @@ public:
 
 ```
 
+* 时间复杂度: push和empty为O(1), pop和peek为O(n)
+* 空间复杂度: O(n)
+
+
 ## 拓展
 
 可以看出peek()的实现，直接复用了pop()， 要不然，对stOut判空的逻辑又要重写一遍。

problems/0239.滑动窗口最大值.md

@@ -184,6 +184,9 @@ public:
     }
 };
 ```
+* 时间复杂度: O(n)
+* 空间复杂度: O(k)
+
 
 再来看一下时间复杂度，使用单调队列的时间复杂度是 O(n)。
 

problems/0347.前K个高频元素.md

@@ -79,8 +79,6 @@
 
 
 ```CPP
-// 时间复杂度：O(nlogk)
-// 空间复杂度：O(n)
 class Solution {
 public:
     // 小顶堆
@@ -120,6 +118,10 @@ public:
     }
 };
 ```
+
+* 时间复杂度: O(nlogk)
+* 空间复杂度: O(n)
+
 # 拓展
 大家对这个比较运算在建堆时是如何应用的，为什么左大于右就会建立小顶堆，反而建立大顶堆比较困惑。
 

problems/0454.四数相加II.md

@@ -97,26 +97,25 @@ Java：
 ```Java
 class Solution {
     public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
-        Map<Integer, Integer> map = new HashMap<>();
-        int temp;
         int res = 0;
+        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
         //统计两个数组中的元素之和，同时统计出现的次数，放入map
         for (int i : nums1) {
             for (int j : nums2) {
-                temp = i + j;
-                if (map.containsKey(temp)) {
-                    map.put(temp, map.get(temp) + 1);
+                int tmp = map.getOrDefault(i + j, 0);
+                if (tmp == 0) {
+                    map.put(i + j, 1);
                 } else {
-                    map.put(temp, 1);
+                    map.replace(i + j, tmp + 1);
                 }
             }
         }
         //统计剩余的两个元素的和，在map中找是否存在相加为0的情况，同时记录次数
         for (int i : nums3) {
             for (int j : nums4) {
-                temp = i + j;
-                if (map.containsKey(0 - temp)) {
-                    res += map.get(0 - temp);
+                int tmp = map.getOrDefault(0 - i - j, 0);
+                if (tmp != 0) {
+                    res += tmp;
                 }
             }
         }