diff --git a/README.md b/README.md
index 113f0cb5..06802c9e 100644
--- a/README.md
+++ b/README.md
@@ -231,6 +231,8 @@
|[0101.对称二叉树](https://github.com/youngyangyang04/leetcode/blob/master/problems/0101.对称二叉树.md) |树 |简单|**递归** **迭代/队列/栈**|
|[0102.二叉树的层序遍历](https://github.com/youngyangyang04/leetcode/blob/master/problems/0102.二叉树的层序遍历.md) |树 |中等|**广度优先搜索/队列**|
|[0104.二叉树的最大深度](https://github.com/youngyangyang04/leetcode/blob/master/problems/0104.二叉树的最大深度.md) |树 |简单|**递归** **迭代/队列/BFS**|
+|[0105.从前序与中序遍历序列构造二叉树](https://github.com/youngyangyang04/leetcode/blob/master/problems/0105.从前序与中序遍历序列构造二叉树.md) |树 |中等|**递归**|
+|[0106.从中序与后序遍历序列构造二叉树](https://github.com/youngyangyang04/leetcode/blob/master/problems/0106.从中序与后序遍历序列构造二叉树.md) |树 |中等|**递归**|
|[0107.二叉树的层次遍历II](https://github.com/youngyangyang04/leetcode/blob/master/problems/0107.二叉树的层次遍历II.md) |树 |简单|**广度优先搜索/队列/BFS**|
|[0110.平衡二叉树](https://github.com/youngyangyang04/leetcode/blob/master/problems/0110.平衡二叉树.md) |树 |简单|**递归**|
|[0111.二叉树的最小深度](https://github.com/youngyangyang04/leetcode/blob/master/problems/0111.二叉树的最小深度.md) |树 |简单|**递归** **队列/BFS**|
@@ -273,7 +275,8 @@
|[0538.把二叉搜索树转换为累加树](https://github.com/youngyangyang04/leetcode/blob/master/problems/0538.把二叉搜索树转换为累加树.md) |二叉树 |简单|**递归** **迭代**|
|[0541.反转字符串II](https://github.com/youngyangyang04/leetcode/blob/master/problems/0541.反转字符串II.md) |字符串 |简单| **模拟**|
|[0575.分糖果](https://github.com/youngyangyang04/leetcode/blob/master/problems/0575.分糖果.md) |哈希表 |简单|**哈希**|
-|[0589.N叉树的前序遍历](https://github.com/youngyangyang04/leetcode/blob/master/problems/0589.N叉树的前序遍历.md) |树 |简单|**递归****栈/迭代**|
+|[0589.N叉树的前序遍历](https://github.com/youngyangyang04/leetcode/blob/master/problems/0589.N叉树的前序遍历.md) |树 |简单|**递归** **栈/迭代**|
+|[0590.N叉树的后序遍历](https://github.com/youngyangyang04/leetcode/blob/master/problems/0590.N叉树的后序遍历.md) |树 |简单|**递归** **栈/迭代**|
|[0617.合并二叉树](https://github.com/youngyangyang04/leetcode/blob/master/problems/0617.合并二叉树.md) |树 |简单|**递归** **迭代**|
|[0637.二叉树的层平均值](https://github.com/youngyangyang04/leetcode/blob/master/problems/0637.二叉树的层平均值.md) |树 |简单|**广度优先搜索/队列**|
|[0654.最大二叉树](https://github.com/youngyangyang04/leetcode/blob/master/problems/0654.最大二叉树.md) |树 |中等|**递归**|
diff --git a/pics/102.二叉树的层序遍历.png b/pics/102.二叉树的层序遍历.png
new file mode 100644
index 00000000..dcfcf972
Binary files /dev/null and b/pics/102.二叉树的层序遍历.png differ
diff --git a/pics/106.从中序与后序遍历序列构造二叉树.png b/pics/106.从中序与后序遍历序列构造二叉树.png
new file mode 100644
index 00000000..081a7813
Binary files /dev/null and b/pics/106.从中序与后序遍历序列构造二叉树.png differ
diff --git a/pics/107.二叉树的层次遍历II.png b/pics/107.二叉树的层次遍历II.png
new file mode 100644
index 00000000..b4021c44
Binary files /dev/null and b/pics/107.二叉树的层次遍历II.png differ
diff --git a/pics/199.二叉树的右视图.png b/pics/199.二叉树的右视图.png
new file mode 100644
index 00000000..e5244117
Binary files /dev/null and b/pics/199.二叉树的右视图.png differ
diff --git a/pics/429. N叉树的层序遍历.png b/pics/429. N叉树的层序遍历.png
new file mode 100644
index 00000000..d28c543c
Binary files /dev/null and b/pics/429. N叉树的层序遍历.png differ
diff --git a/pics/637.二叉树的层平均值.png b/pics/637.二叉树的层平均值.png
new file mode 100644
index 00000000..57018dab
Binary files /dev/null and b/pics/637.二叉树的层平均值.png differ
diff --git a/pics/我要打十个.gif b/pics/我要打十个.gif
new file mode 100644
index 00000000..c64eb70a
Binary files /dev/null and b/pics/我要打十个.gif differ
diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index 04520204..318f444f 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -1,27 +1,41 @@
## 题目地址
https://leetcode-cn.com/problems/binary-tree-level-order-traversal/
+> 我要打十个！
+
+看完这篇文章虽然不能打十个，但是可以迅速打五个！而且够快！
+
+
+# 102.二叉树的层序遍历
+
+给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。
+
+
+
## 思路
-我们之前讲过了，二叉树的深度优先遍历：[一文学通二叉树前中后序递归法与迭代法](https://github.com/youngyangyang04/leetcode/blob/master/problems/0144.二叉树的前序遍历.md)里面有前中后序遍历的方式，前中后序分辨可以使用递归和迭代的方法来实现，接下来我们再来介绍二叉树的另一种遍历方式，也就是层序遍历。
+我们之前讲过了三篇关于二叉树的深度优先遍历的文章：
-相似题目：
-* [0102.二叉树的层序遍历](https://github.com/youngyangyang04/leetcode/blob/master/problems/0102.二叉树的层序遍历.md)
-* [0107.二叉树的层次遍历II](https://github.com/youngyangyang04/leetcode/blob/master/problems/0107.二叉树的层次遍历II.md)
-* [0199.二叉树的右视图](https://github.com/youngyangyang04/leetcode/blob/master/problems/0199.二叉树的右视图.md)
-* [0637.二叉树的层平均值](https://github.com/youngyangyang04/leetcode/blob/master/problems/0637.二叉树的层平均值.md)
+* [二叉树：前中后序递归法](https://mp.weixin.qq.com/s/PwVIfxDlT3kRgMASWAMGhA)
+* [二叉树：前中后序迭代法](https://mp.weixin.qq.com/s/c_zCrGHIVlBjUH_hJtghCg)
+* [二叉树：前中后序迭代方式统一写法](https://mp.weixin.qq.com/s/WKg0Ty1_3SZkztpHubZPRg)
+
+接下来我们再来介绍二叉树的另一种遍历方式：层序遍历。
层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。这种遍历的方式和我们之前讲过的都不太一样。
-需要借用一个辅助数据结构队列来实现，**队列先进先出，符合一层一层遍历的逻辑，而是用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。**
+需要借用一个辅助数据结构即队列来实现，**队列先进先出，符合一层一层遍历的逻辑，而是用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。**
-使用队列实现广度优先遍历，动画如下：
+**而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。**
+使用队列实现二叉树广度优先遍历，动画如下：
+
+
这样就实现了层序从左到右遍历二叉树。
-代码如下：这份代码也可以作为二叉树层序遍历的模板。
+代码如下：**这份代码也可以作为二叉树层序遍历的模板，以后在打四个就靠它了**。
## C++代码
@@ -35,7 +49,8 @@ public:
while (!que.empty()) {
int size = que.size();
vector vec;
- for (int i = 0; i < size; i++) {// 这里一定要使用固定大小size，不要使用que.size()
+ // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
+ for (int i = 0; i < size; i++) {
TreeNode* node = que.front();
que.pop();
vec.push_back(node->val);
@@ -49,4 +64,186 @@ public:
};
```
+**此时我们就掌握了二叉树的层序遍历了，那么如下四道leetcode上的题目，只需要修改模板的一两行代码（不能再多了），便可打倒！**
+
+# 107.二叉树的层次遍历 II
+
+给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）
+
+
+
+## 思路
+
+相对于102.二叉树的层序遍历，就是最后把result数组反转一下就可以了。
+
+## C++代码
+
+```
+class Solution {
+public:
+ vector> levelOrderBottom(TreeNode* root) {
+ queue que;
+ if (root != NULL) que.push(root);
+ vector> result;
+ while (!que.empty()) {
+ int size = que.size();
+ vector vec;
+ for (int i = 0; i < size; i++) {
+ TreeNode* node = que.front();
+ que.pop();
+ vec.push_back(node->val);
+ if (node->left) que.push(node->left);
+ if (node->right) que.push(node->right);
+ }
+ result.push_back(vec);
+ }
+ reverse(result.begin(), result.end()); // 在这里反转一下数组即可
+ return result;
+
+ }
+};
+```
+
+
+# 199.二叉树的右视图
+
+给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
+
+
+
+## 思路
+
+层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进result数组中，随后返回result就可以了。
+
+## C++代码
+
+```
+class Solution {
+public:
+ vector rightSideView(TreeNode* root) {
+ queue que;
+ if (root != NULL) que.push(root);
+ vector result;
+ while (!que.empty()) {
+ int size = que.size();
+ for (int i = 0; i < size; i++) {
+ TreeNode* node = que.front();
+ que.pop();
+ if (i == (size - 1)) result.push_back(node->val); // 将每一层的最后元素放入result数组中
+ if (node->left) que.push(node->left);
+ if (node->right) que.push(node->right);
+ }
+ }
+ return result;
+ }
+};
+```
+
+# 637.二叉树的层平均值
+
+给定一个非空二叉树, 返回一个由每层节点平均值组成的数组。
+
+
+
+## 思路
+
+本题就是层序遍历的时候把一层求个总和在取一个均值。
+
+## C++代码
+
+```
+class Solution {
+public:
+ vector averageOfLevels(TreeNode* root) {
+ queue que;
+ if (root != NULL) que.push(root);
+ vector result;
+ while (!que.empty()) {
+ int size = que.size();
+ double sum = 0; // 统计每一层的和
+ for (int i = 0; i < size; i++) {
+ TreeNode* node = que.front();
+ que.pop();
+ sum += node->val;
+ if (node->left) que.push(node->left);
+ if (node->right) que.push(node->right);
+ }
+ result.push_back(sum / size); // 将每一层均值放进结果集
+ }
+ return result;
+ }
+};
+
+```
+
+# 429.N叉树的层序遍历
+
+给定一个 N 叉树，返回其节点值的层序遍历。 (即从左到右，逐层遍历)。
+
+例如，给定一个 3叉树 :
+
+
+
+
+返回其层序遍历:
+
+[
+ [1],
+ [3,2,4],
+ [5,6]
+]
+
+
+## 思路
+
+这道题依旧是模板题，只不过一个节点有多个孩子了
+
+## C++代码
+
+```
+class Solution {
+public:
+ vector> levelOrder(Node* root) {
+ queue que;
+ if (root != NULL) que.push(root);
+ vector> result;
+ while (!que.empty()) {
+ int size = que.size();
+ vector vec;
+ for (int i = 0; i < size; i++) {
+ Node* node = que.front();
+ que.pop();
+ vec.push_back(node->val);
+ for (int i = 0; i < node->children.size(); i++) { // 将节点孩子加入队列
+ if (node->children[i]) que.push(node->children[i]);
+ }
+ }
+ result.push_back(vec);
+ }
+ return result;
+
+ }
+};
+```
+
+# 总结
+
+二叉树的层序遍历，就是图论中的广度优先搜索在二叉树中的应用，需要借助队列来实现（此时是不是又发现队列的应用了）。
+
+学会二叉树的层序遍历，可以一口气撸完leetcode上五道题目：
+
+* 102.二叉树的层序遍历
+* 107.二叉树的层次遍历II
+* 199.二叉树的右视图
+* 637.二叉树的层平均值
+* 589.N叉树的前序遍历
+
+虽然不能一口气打十个，打五个也还行。
+
+如果非要打十个，还得找叶师傅！
+
+
+
+
+
> 更多算法干货文章持续更新，可以微信搜索「代码随想录」第一时间围观，关注后，回复「Java」「C++」 「python」「简历模板」「数据结构与算法」等等，就可以获得我多年整理的学习资料。
diff --git a/problems/0105.从前序与中序遍历序列构造二叉树.md b/problems/0105.从前序与中序遍历序列构造二叉树.md
new file mode 100644
index 00000000..eb39b313
--- /dev/null
+++ b/problems/0105.从前序与中序遍历序列构造二叉树.md
@@ -0,0 +1,8 @@
+# 链接
+
+https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/
+
+# 思路：
+
+详细见
+[0106.从中序与后序遍历序列构造二叉树](https://github.com/youngyangyang04/leetcode/blob/master/problems/0106.从中序与后序遍历序列构造二叉树.md)
diff --git a/problems/0106.从中序与后序遍历序列构造二叉树.md b/problems/0106.从中序与后序遍历序列构造二叉树.md
new file mode 100644
index 00000000..6af49fd6
--- /dev/null
+++ b/problems/0106.从中序与后序遍历序列构造二叉树.md
@@ -0,0 +1,495 @@
+## 题目地址
+https://leetcode-cn.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/
+
+## 思路
+
+首先回忆一下如何根据两个顺序构造一个唯一的二叉树，相信理论知识大家应该都清楚，就是以后序数组最后一个元素为切割点，先切中序数组，根据中序数组，反过来在切后序数组。一层一层切下去，每次后序数组最后一个元素就是节点元素。
+
+如果让我们肉眼看两个序列，画一颗二叉树的话，应该分分钟都可以画出来。
+
+流程如图：
+
+
+
+
+那么代码应该怎么写呢？
+
+说道一层一层切割，就应该想到了递归。
+
+来看一下一共分几步：
+
+* 第一步：如果数组大小为零的话，说明是空节点了。
+
+* 第二步：如果不为空，那么取后序数组最后一个元素作为节点元素。
+
+* 第三步：找到后序数组最后一个元素在后序数组的位置，作为切割点
+
+* 第四步：切割中序数组，切成中序左数组和中序右数组 （顺序别搞反了，一定是先切中序数组）
+
+* 第五步：切割后序数组，切成后序左数组和后序右数组
+
+* 第六步：递归处理左区间和右区间
+
+不难写出如下代码：（先把框架写出来）
+
+```
+ TreeNode* traversal (vector& inorder, vector& postorder) {
+
+ if (postorder.size() == 0) return NULL;
+
+ // 后序遍历数组最后一个元素，就是当前的中间节点
+ int rootValue = postorder[postorder.size() - 1];
+ TreeNode* root = new TreeNode(rootValue);
+
+ // 叶子节点
+ if (postorder.size() == 1) return root;
+
+ 找切割点
+ int delimiterIndex;
+ for (delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {
+ if (inorder[delimiterIndex] == rootValue) break;
+ }
+
+ 切割中序数组，得到 中序左数组和中序右数组
+ 切割后序数组，得到 后序左数组和后序右数组
+
+ root->left = traversal(中序左数组, 后序左数组);
+ root->right = traversal(中序右数组, 后序右数组);
+
+ return root;
+ }
+```
+
+难点大家应该发现了，如何切割呢，边界值找不好很容易乱套。
+
+此时应该注意确定切割的标准，是左闭右开，还有左开又闭，还是左闭又闭，这个就是不变量，要在递归中保持这个不变量。
+
+在切割的过程中会产生四个区间，把握不好不变量的话，一会左闭右开，一会左闭又闭，必要乱套！
+
+我在[数组：每次遇到二分法，都是一看就会，一写就废](https://mp.weixin.qq.com/s/fCf5QbPDtE6SSlZ1yh_q8Q)和[数组：这个循环可以转懵很多人！](https://mp.weixin.qq.com/s/KTPhaeqxbMK9CxHUUgFDmg)中都强调过循环不变量的重要性，在二分查找以及螺旋矩阵的求解中，坚持循环不变量非常重要，本题也是。
+
+
+首先要切割中序数组，为什么先切割中序数组呢？
+
+切割点在后序数组的最后一个元素，就是用这个元素来切割中序数组的，所以必要先切割中序数组。
+
+中序数组相对比较好切，找到切割点（后序数组的最后一个元素）在中序数组的位置，然后切割，如下代码中我坚持左闭右开的原则：
+
+
+```
+ // 找到中序遍历的切割点
+ int delimiterIndex;
+ for (delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {
+ if (inorder[delimiterIndex] == rootValue) break;
+ }
+
+ // 左闭右开区间
+ // [0, delimiterIndex)
+ vector leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);
+ // [delimiterIndex + 1, end)
+ vector rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end() );
+```
+
+接下来就要切割后序数组了。
+
+首先后序数组的最后一个元素指定不能要了，这是切割点 也是 当前二叉树中间节点的元素，已经用了。
+
+后序数组的切割点怎么找？
+
+后序数组没有明确的切割元素来进行左右切割，不想中序数组有明确的切割左右，左右分开就可以了。
+
+**此时有一个很重的点，就是中序数组大小一定是和后序数组的大小相同的（这是必然）。**
+
+中序数组我们都切成了左中序数组和右中序数组了，那么后序数组就可以按照左中序数组的大小来切割，切成左后序数组和右后序数组。
+
+代码如下：
+
+```
+ // postorder 舍弃末尾元素
+ postorder.resize(postorder.size() - 1);
+
+ // 依然左闭右开，注意这里使用了左中序数组大小作为切割点
+ // [0, leftInorder.size)
+ vector leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
+ // [leftInorder.size(), end)
+ vector rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());
+```
+
+此时，中序数组切成了左中序数组和右中序数组，后序数组切割成序数组和右后序数组。
+
+接下来可以递归了，代码如下：
+
+```
+ root->left = traversal(leftInorder, leftPostorder);
+ root->right = traversal(rightInorder, rightPostorder);
+```
+
+完整代码如下：
+
+## C++ 完整代码
+
+```
+class Solution {
+private:
+ TreeNode* traversal (vector& inorder, vector& postorder) {
+ if (postorder.size() == 0) return NULL;
+
+ // 后序遍历数组最后一个元素，就是当前的中间节点
+ int rootValue = postorder[postorder.size() - 1];
+ TreeNode* root = new TreeNode(rootValue);
+
+ // 叶子节点
+ if (postorder.size() == 1) return root;
+
+ // 找到中序遍历的切割点
+ int delimiterIndex;
+ for (delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {
+ if (inorder[delimiterIndex] == rootValue) break;
+ }
+
+ // 切割中序数组
+ // 左闭右开区间：[0, delimiterIndex)
+ vector leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);
+ // [delimiterIndex + 1, end)
+ vector rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end() );
+
+ // postorder 舍弃末尾元素
+ postorder.resize(postorder.size() - 1);
+
+ // 切割后序数组
+ // 依然左闭右开，注意这里使用了左中序数组大小作为切割点
+ // [0, leftInorder.size)
+ vector leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
+ // [leftInorder.size(), end)
+ vector rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());
+
+ root->left = traversal(leftInorder, leftPostorder);
+ root->right = traversal(rightInorder, rightPostorder);
+
+ return root;
+ }
+public:
+ TreeNode* buildTree(vector& inorder, vector& postorder) {
+ if (inorder.size() == 0 || postorder.size() == 0) return NULL;
+ return traversal(inorder, postorder);
+ }
+};
+
+```
+
+相信大家自己就算是思路清晰， 代码写出来一定是各种问题，所以一定要加日志来调试，看看是不是按照自己思路来切割的，不要大脑模拟，那样越想越糊涂。
+
+加了日志的代码如下：（加了日志的代码不要在leetcode上提交，容易超时）
+
+
+```
+class Solution {
+private:
+ TreeNode* traversal (vector& inorder, vector& postorder) {
+ if (postorder.size() == 0) return NULL;
+
+ int rootValue = postorder[postorder.size() - 1];
+ TreeNode* root = new TreeNode(rootValue);
+
+ if (postorder.size() == 1) return root;
+
+ int delimiterIndex;
+ for (delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {
+ if (inorder[delimiterIndex] == rootValue) break;
+ }
+
+ vector leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);
+ vector rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end() );
+
+ postorder.resize(postorder.size() - 1);
+
+ vector leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
+ vector rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());
+
+ cout << "----------" << endl;
+
+ cout << "leftInorder :";
+ for (int i : leftInorder) {
+ cout << i << " ";
+ }
+ cout << endl;
+
+ cout << "rightInorder :";
+ for (int i : rightInorder) {
+ cout << i << " ";
+ }
+ cout << endl;
+
+ cout << "leftPostorder :";
+ for (int i : leftPostorder) {
+ cout << i << " ";
+ }
+ cout << endl;
+ cout << "rightPostorder :";
+ for (int i : rightPostorder) {
+ cout << i << " ";
+ }
+ cout << endl;
+
+ root->left = traversal(leftInorder, leftPostorder);
+ root->right = traversal(rightInorder, rightPostorder);
+
+ return root;
+ }
+public:
+ TreeNode* buildTree(vector& inorder, vector& postorder) {
+ if (inorder.size() == 0 || postorder.size() == 0) return NULL;
+ return traversal(inorder, postorder);
+ }
+};
+```
+
+**此时应该发现了，如上的代码性能并不好，应为每层递归定定义了新的vector，既耗时又耗空间，但是上面的代码是最好理解的，为了方便读者理解，所以用如上的代码来讲解。**
+
+下面给出用下表索引写出的代码版本：（思路是一样的，只不过不用重复定义vector了，每次用下表索引来分割）
+
+## C++最终优化版本
+```
+class Solution {
+private:
+ // 中序区间：[inorderBegin, inorderEnd)，后序区间[postorderBegin, postorderEnd)
+ TreeNode* traversal (vector& inorder, int inorderBegin, int inorderEnd, vector& postorder, int postorderBegin, int postorderEnd) {
+ if (postorderBegin == postorderEnd) return NULL;
+
+ int rootValue = postorder[postorderEnd - 1];
+ TreeNode* root = new TreeNode(rootValue);
+
+ if (postorderEnd - postorderBegin == 1) return root;
+
+ int delimiterIndex;
+ for (delimiterIndex = inorderBegin; delimiterIndex < inorderEnd; delimiterIndex++) {
+ if (inorder[delimiterIndex] == rootValue) break;
+ }
+ // 切割中序数组
+ // 左中序区间，左闭右开[leftInorderBegin, leftInorderEnd)
+ int leftInorderBegin = inorderBegin;
+ int leftInorderEnd = delimiterIndex;
+ // 右中序区间，左闭右开[rightInorderBegin, rightInorderEnd)
+ int rightInorderBegin = delimiterIndex + 1;
+ int rightInorderEnd = inorderEnd;
+
+ // 切割后序数组
+ // 左后序区间，左闭右开[leftPostorderBegin, leftPostorderEnd)
+ int leftPostorderBegin = postorderBegin;
+ int leftPostorderEnd = postorderBegin + delimiterIndex - inorderBegin; // 终止位置是 需要加上 中序区间的大小size
+ // 右后序区间，左闭右开[rightPostorderBegin, rightPostorderEnd)
+ int rightPostorderBegin = postorderBegin + (delimiterIndex - inorderBegin);
+ int rightPostorderEnd = postorderEnd - 1; // 排除最后一个元素，已经作为节点了
+
+ root->left = traversal(inorder, leftInorderBegin, leftInorderEnd, postorder, leftPostorderBegin, leftPostorderEnd);
+ root->right = traversal(inorder, rightInorderBegin, rightInorderEnd, postorder, rightPostorderBegin, rightPostorderEnd);
+
+ return root;
+ }
+public:
+ TreeNode* buildTree(vector& inorder, vector& postorder) {
+ if (inorder.size() == 0 || postorder.size() == 0) return NULL;
+ // 左闭右开的原则
+ return traversal(inorder, 0, inorder.size(), postorder, 0, postorder.size());
+ }
+};
+```
+
+那么这个版本写出来依然要打日志进行调试，打日志的版本如下：（**该版本不要在leetcode上提交，容易超时**）
+
+```
+class Solution {
+private:
+ TreeNode* traversal (vector& inorder, int inorderBegin, int inorderEnd, vector& postorder, int postorderBegin, int postorderEnd) {
+ if (postorderBegin == postorderEnd) return NULL;
+
+ int rootValue = postorder[postorderEnd - 1];
+ TreeNode* root = new TreeNode(rootValue);
+
+ if (postorderEnd - postorderBegin == 1) return root;
+
+ int delimiterIndex;
+ for (delimiterIndex = inorderBegin; delimiterIndex < inorderEnd; delimiterIndex++) {
+ if (inorder[delimiterIndex] == rootValue) break;
+ }
+ // 切割中序数组
+ // 左中序区间，左闭右开[leftInorderBegin, leftInorderEnd)
+ int leftInorderBegin = inorderBegin;
+ int leftInorderEnd = delimiterIndex;
+ // 右中序区间，左闭右开[rightInorderBegin, rightInorderEnd)
+ int rightInorderBegin = delimiterIndex + 1;
+ int rightInorderEnd = inorderEnd;
+
+ // 切割后序数组
+ // 左后序区间，左闭右开[leftPostorderBegin, leftPostorderEnd)
+ int leftPostorderBegin = postorderBegin;
+ int leftPostorderEnd = postorderBegin + delimiterIndex - inorderBegin; // 终止位置是 需要加上 中序区间的大小size
+ // 右后序区间，左闭右开[rightPostorderBegin, rightPostorderEnd)
+ int rightPostorderBegin = postorderBegin + (delimiterIndex - inorderBegin);
+ int rightPostorderEnd = postorderEnd - 1; // 排除最后一个元素，已经作为节点了
+
+ cout << "----------" << endl;
+ cout << "leftInorder :";
+ for (int i = leftInorderBegin; i < leftInorderEnd; i++) {
+ cout << inorder[i] << " ";
+ }
+ cout << endl;
+
+ cout << "rightInorder :";
+ for (int i = rightInorderBegin; i < rightInorderEnd; i++) {
+ cout << inorder[i] << " ";
+ }
+ cout << endl;
+
+ cout << "leftpostorder :";
+ for (int i = leftPostorderBegin; i < leftPostorderEnd; i++) {
+ cout << postorder[i] << " ";
+ }
+ cout << endl;
+
+ cout << "rightpostorder :";
+ for (int i = rightPostorderBegin; i < rightPostorderEnd; i++) {
+ cout << postorder[i] << " ";
+ }
+ cout << endl;
+
+ root->left = traversal(inorder, leftInorderBegin, leftInorderEnd, postorder, leftPostorderBegin, leftPostorderEnd);
+ root->right = traversal(inorder, rightInorderBegin, rightInorderEnd, postorder, rightPostorderBegin, rightPostorderEnd);
+
+ return root;
+ }
+public:
+ TreeNode* buildTree(vector& inorder, vector& postorder) {
+ if (inorder.size() == 0 || postorder.size() == 0) return NULL;
+ return traversal(inorder, 0, inorder.size(), postorder, 0, postorder.size());
+ }
+};
+```
+
+# 105. 从前序与中序遍历序列构造二叉树
+
+同样的道理
+
+带日志的版本C++代码如下： （**带日志的版本仅用于调试，不要在leetcode上提交，会超时**）
+
+```
+class Solution {
+private:
+ TreeNode* traversal (vector& inorder, int inorderBegin, int inorderEnd, vector& preorder, int preorderBegin, int preorderEnd) {
+ if (preorderBegin == preorderEnd) return NULL;
+
+ int rootValue = preorder[preorderBegin]; // 注意用preorderBegin 不要用0
+ TreeNode* root = new TreeNode(rootValue);
+
+ if (preorderEnd - preorderBegin == 1) return root;
+
+ int delimiterIndex;
+ for (delimiterIndex = inorderBegin; delimiterIndex < inorderEnd; delimiterIndex++) {
+ if (inorder[delimiterIndex] == rootValue) break;
+ }
+ // 切割中序数组
+ // 中序左区间，左闭右开[leftInorderBegin, leftInorderEnd)
+ int leftInorderBegin = inorderBegin;
+ int leftInorderEnd = delimiterIndex;
+ // 中序右区间，左闭右开[rightInorderBegin, rightInorderEnd)
+ int rightInorderBegin = delimiterIndex + 1;
+ int rightInorderEnd = inorderEnd;
+
+ // 切割前序数组
+ // 前序左区间，左闭右开[leftPreorderBegin, leftPreorderEnd)
+ int leftPreorderBegin = preorderBegin + 1;
+ int leftPreorderEnd = preorderBegin + 1 + delimiterIndex - inorderBegin; // 终止位置是起始位置加上中序左区间的大小size
+ // 前序右区间, 左闭右开[rightPreorderBegin, rightPreorderEnd)
+ int rightPreorderBegin = preorderBegin + 1 + (delimiterIndex - inorderBegin);
+ int rightPreorderEnd = preorderEnd;
+
+ cout << "----------" << endl;
+ cout << "leftInorder :";
+ for (int i = leftInorderBegin; i < leftInorderEnd; i++) {
+ cout << inorder[i] << " ";
+ }
+ cout << endl;
+
+ cout << "rightInorder :";
+ for (int i = rightInorderBegin; i < rightInorderEnd; i++) {
+ cout << inorder[i] << " ";
+ }
+ cout << endl;
+
+ cout << "leftPreorder :";
+ for (int i = leftPreorderBegin; i < leftPreorderEnd; i++) {
+ cout << preorder[i] << " ";
+ }
+ cout << endl;
+
+ cout << "rightPreorder :";
+ for (int i = rightPreorderBegin; i < rightPreorderEnd; i++) {
+ cout << preorder[i] << " ";
+ }
+ cout << endl;
+
+
+ root->left = traversal(inorder, leftInorderBegin, leftInorderEnd, preorder, leftPreorderBegin, leftPreorderEnd);
+ root->right = traversal(inorder, rightInorderBegin, rightInorderEnd, preorder, rightPreorderBegin, rightPreorderEnd);
+
+ return root;
+ }
+
+public:
+ TreeNode* buildTree(vector& preorder, vector& inorder) {
+ if (inorder.size() == 0 || preorder.size() == 0) return NULL;
+ return traversal(inorder, 0, inorder.size(), preorder, 0, preorder.size());
+
+ }
+};
+```
+
+105. 从前序与中序遍历序列构造二叉树，最后版本：
+
+C++代码：
+```
+class Solution {
+private:
+ TreeNode* traversal (vector& inorder, int inorderBegin, int inorderEnd, vector& preorder, int preorderBegin, int preorderEnd) {
+ if (preorderBegin == preorderEnd) return NULL;
+
+ int rootValue = preorder[preorderBegin]; // 注意用preorderBegin 不要用0
+ TreeNode* root = new TreeNode(rootValue);
+
+ if (preorderEnd - preorderBegin == 1) return root;
+
+ int delimiterIndex;
+ for (delimiterIndex = inorderBegin; delimiterIndex < inorderEnd; delimiterIndex++) {
+ if (inorder[delimiterIndex] == rootValue) break;
+ }
+ // 切割中序数组
+ // 中序左区间，左闭右开[leftInorderBegin, leftInorderEnd)
+ int leftInorderBegin = inorderBegin;
+ int leftInorderEnd = delimiterIndex;
+ // 中序右区间，左闭右开[rightInorderBegin, rightInorderEnd)
+ int rightInorderBegin = delimiterIndex + 1;
+ int rightInorderEnd = inorderEnd;
+
+ // 切割前序数组
+ // 前序左区间，左闭右开[leftPreorderBegin, leftPreorderEnd)
+ int leftPreorderBegin = preorderBegin + 1;
+ int leftPreorderEnd = preorderBegin + 1 + delimiterIndex - inorderBegin; // 终止位置是起始位置加上中序左区间的大小size
+ // 前序右区间, 左闭右开[rightPreorderBegin, rightPreorderEnd)
+ int rightPreorderBegin = preorderBegin + 1 + (delimiterIndex - inorderBegin);
+ int rightPreorderEnd = preorderEnd;
+
+ root->left = traversal(inorder, leftInorderBegin, leftInorderEnd, preorder, leftPreorderBegin, leftPreorderEnd);
+ root->right = traversal(inorder, rightInorderBegin, rightInorderEnd, preorder, rightPreorderBegin, rightPreorderEnd);
+
+ return root;
+ }
+
+public:
+ TreeNode* buildTree(vector& preorder, vector& inorder) {
+ if (inorder.size() == 0 || preorder.size() == 0) return NULL;
+
+ // 参数坚持左闭右开的原则
+ return traversal(inorder, 0, inorder.size(), preorder, 0, preorder.size());
+ }
+};
+```
diff --git a/problems/0429.N叉树的层序遍历.md b/problems/0429.N叉树的层序遍历.md
new file mode 100644
index 00000000..7dc76d1b
--- /dev/null
+++ b/problems/0429.N叉树的层序遍历.md
@@ -0,0 +1,35 @@
+
+## 题目地址
+https://leetcode-cn.com/problems/sum-of-left-leaves/
+
+## 思路
+
+层序遍历，和 102题目一个套路
+
+## C++代码
+
+```
+class Solution {
+public:
+ vector> levelOrder(Node* root) {
+ queue que;
+ if (root != NULL) que.push(root);
+ vector> result;
+ while (!que.empty()) {
+ int size = que.size();
+ vector vec;
+ for (int i = 0; i < size; i++) { // 这里一定要使用固定大小size，不要使用que.size()
+ Node* node = que.front();
+ que.pop();
+ vec.push_back(node->val);
+ for (int i = 0; i < node->children.size(); i++) {
+ if (node->children[i]) que.push(node->children[i]);
+ }
+ }
+ result.push_back(vec);
+ }
+ return result;
+
+ }
+};
+```
diff --git a/problems/0589.N叉树的前序遍历.md b/problems/0589.N叉树的前序遍历.md
new file mode 100644
index 00000000..dfb7cf78
--- /dev/null
+++ b/problems/0589.N叉树的前序遍历.md
@@ -0,0 +1,56 @@
+## 题目地址
+https://leetcode-cn.com/problems/n-ary-tree-preorder-traversal/
+
+## 思路
+
+
+
+## 递归C++代码
+
+```
+class Solution {
+private:
+ vector result;
+ void traversal (Node* root) {
+ if (root == NULL) return;
+ result.push_back(root->val);
+ for (int i = 0; i < root->children.size(); i++) {
+ traversal(root->children[i]);
+ }
+ }
+
+public:
+ vector preorder(Node* root) {
+ result.clear();
+ traversal(root);
+ return result;
+ }
+};
+```
+
+## 迭代法C++代码
+
+```
+class Solution {
+
+public:
+ vector preorder(Node* root) {
+ vector result;
+ if (root == NULL) return result;
+ stack st;
+ st.push(root);
+ while (!st.empty()) {
+ Node* node = st.top();
+ st.pop();
+ result.push_back(node->val);
+ // 注意要倒叙，这样才能达到前序（中左右）的效果
+ for (int i = node->children.size() - 1; i >= 0; i--) {
+ if (node->children[i] != NULL) {
+ st.push(node->children[i]);
+ }
+ }
+ }
+ return result;
+ }
+};
+```
diff --git a/problems/0590.N叉树的后序遍历.md b/problems/0590.N叉树的后序遍历.md
new file mode 100644
index 00000000..36c98fef
--- /dev/null
+++ b/problems/0590.N叉树的后序遍历.md
@@ -0,0 +1,54 @@
+## 题目地址
+https://leetcode-cn.com/problems/n-ary-tree-postorder-traversal/
+## 思路
+
+## 递归C++代码
+
+```
+class Solution {
+private:
+ vector result;
+ void traversal (Node* root) {
+ if (root == NULL) return;
+ for (int i = 0; i < root->children.size(); i++) { // 子孩子
+ traversal(root->children[i]);
+ }
+ result.push_back(root->val); // 中
+
+ }
+
+public:
+ vector postorder(Node* root) {
+ result.clear();
+ traversal(root);
+ return result;
+
+ }
+};
+```
+
+## 迭代法C++代码
+
+```
+class Solution {
+public:
+ vector postorder(Node* root) {
+ vector result;
+ if (root == NULL) return result;
+ stack st;
+ st.push(root);
+ while (!st.empty()) {
+ Node* node = st.top();
+ st.pop();
+ result.push_back(node->val);
+ for (int i = 0; i < node->children.size(); i++) { // 相对于前序遍历，这里反过来
+ if (node->children[i] != NULL) {
+ st.push(node->children[i]);
+ }
+ }
+ }
+ reverse(result.begin(), result.end()); // 反转数组
+ return result;
+ }
+};
+```