diff --git a/problems/0045.跳跃游戏II.md b/problems/0045.跳跃游戏II.md
index c6e4e9b5..558b32b9 100644
--- a/problems/0045.跳跃游戏II.md
+++ b/problems/0045.跳跃游戏II.md
@@ -88,6 +88,10 @@ public:
 };
 ```
 
+* 时间复杂度: O(n)
+* 空间复杂度: O(1)
+
+
 ## 方法二
 
 依然是贪心，思路和方法一差不多，代码可以简洁一些。
@@ -127,6 +131,11 @@ public:
 };
 ```
 
+* 时间复杂度: O(n)
+* 空间复杂度: O(1)
+
+
+
 可以看出版本二的代码相对于版本一简化了不少！
 
 **其精髓在于控制移动下标 i 只移动到 nums.size() - 2 的位置**，所以移动下标只要遇到当前覆盖最远距离的下标，直接步数加一，不用考虑别的了。
diff --git a/problems/0053.最大子序和.md b/problems/0053.最大子序和.md
index 1de68041..48f8be29 100644
--- a/problems/0053.最大子序和.md
+++ b/problems/0053.最大子序和.md
@@ -24,8 +24,6 @@
 
 暴力解法的思路，第一层 for 就是设置起始位置，第二层 for 循环遍历数组寻找最大值
 
-- 时间复杂度：O(n^2)
-- 空间复杂度：O(1)
 
 ```CPP
 class Solution {
@@ -44,6 +42,9 @@ public:
     }
 };
 ```
+* 时间复杂度：O(n^2)
+* 空间复杂度：O(1)
+
 
 以上暴力的解法 C++勉强可以过，其他语言就不确定了。
 
@@ -98,7 +99,6 @@ public:
     }
 };
 ```
-
 - 时间复杂度：O(n)
 - 空间复杂度：O(1)
 
diff --git a/problems/0055.跳跃游戏.md b/problems/0055.跳跃游戏.md
index ce9a21ec..c187ef8f 100644
--- a/problems/0055.跳跃游戏.md
+++ b/problems/0055.跳跃游戏.md
@@ -75,6 +75,10 @@ public:
 };
 ```
 
+* 时间复杂度: O(n)
+* 空间复杂度: O(1)
+
+
 ## 总结
 
 这道题目关键点在于：不用拘泥于每次究竟跳几步，而是看覆盖范围，覆盖范围内一定是可以跳过来的，不用管是怎么跳的。
diff --git a/problems/0056.合并区间.md b/problems/0056.合并区间.md
index ec659108..72dc69c5 100644
--- a/problems/0056.合并区间.md
+++ b/problems/0056.合并区间.md
@@ -73,6 +73,10 @@ public:
 };
 ```
 
+* 时间复杂度: O(nlogn)
+* 空间复杂度: O(logn)，排序需要的空间开销
+
+
 ## 其他语言版本
 
 
diff --git a/problems/0135.分发糖果.md b/problems/0135.分发糖果.md
index ef79868a..1ba1563f 100644
--- a/problems/0135.分发糖果.md
+++ b/problems/0135.分发糖果.md
@@ -121,6 +121,11 @@ public:
 };
 ```
 
+* 时间复杂度: O(n)
+* 空间复杂度: O(n)
+
+
+
 ## 总结
 
 这在leetcode上是一道困难的题目，其难点就在于贪心的策略，如果在考虑局部的时候想两边兼顾，就会顾此失彼。
diff --git a/problems/0455.分发饼干.md b/problems/0455.分发饼干.md
index 3688b3fd..efadb433 100644
--- a/problems/0455.分发饼干.md
+++ b/problems/0455.分发饼干.md
@@ -56,8 +56,6 @@ C++代码整体如下：
 
 ```CPP
 // 版本一
-// 时间复杂度：O(nlogn)
-// 空间复杂度：O(1)
 class Solution {
 public:
     int findContentChildren(vector<int>& g, vector<int>& s) {
@@ -75,6 +73,9 @@ public:
     }
 };
 ```
+* 时间复杂度：O(nlogn)
+* 空间复杂度：O(1)
+
 
 从代码中可以看出我用了一个 index 来控制饼干数组的遍历，遍历饼干并没有再起一个 for 循环，而是采用自减的方式，这也是常用的技巧。
 
@@ -118,6 +119,9 @@ public:
     }
 };
 ```
+* 时间复杂度：O(nlogn)
+* 空间复杂度：O(1)
+
 
 细心的录友可以发现，这种写法，两个循环的顺序改变了，先遍历的饼干，在遍历的胃口，这是因为遍历顺序变了，我们是从小到大遍历。
 
diff --git a/problems/0860.柠檬水找零.md b/problems/0860.柠檬水找零.md
index cd52adb0..d96e0879 100644
--- a/problems/0860.柠檬水找零.md
+++ b/problems/0860.柠檬水找零.md
@@ -115,6 +115,9 @@ public:
     }
 };
 ```
+* 时间复杂度: O(n)
+* 空间复杂度: O(1)
+
 
 ## 总结
 
diff --git a/problems/0968.监控二叉树.md b/problems/0968.监控二叉树.md
index 267e7f6e..fdec56ca 100644
--- a/problems/0968.监控二叉树.md
+++ b/problems/0968.监控二叉树.md
@@ -303,6 +303,11 @@ public:
 
 ```
 
+* 时间复杂度: O(n)，需要遍历二叉树上的每个节点
+* 空间复杂度: O(n)
+
+
+
 大家可能会惊讶，居然可以这么简短，**其实就是在版本一的基础上，使用else把一些情况直接覆盖掉了**。
 
 在网上关于这道题解可以搜到很多这种神级别的代码，但都没讲不清楚，如果直接看代码的话，指定越看越晕，**所以建议大家对着版本一的代码一步一步来，版本二中看不中用！**。
diff --git a/problems/1005.K次取反后最大化的数组和.md b/problems/1005.K次取反后最大化的数组和.md
index 4a080857..27a575c7 100644
--- a/problems/1005.K次取反后最大化的数组和.md
+++ b/problems/1005.K次取反后最大化的数组和.md
@@ -85,6 +85,10 @@ public:
 };
 ```
 
+* 时间复杂度: O(nlogn)
+* 空间复杂度: O(1)
+
+
 ## 总结
 
 贪心的题目如果简单起来，会让人简单到开始怀疑：本来不就应该这么做么？这也算是算法？我认为这不是贪心？