Update

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) |树 |中等|**递归**|

problems/0102.二叉树的层序遍历.md

@@ -1,27 +1,41 @@
 ## 题目地址 
 https://leetcode-cn.com/problems/binary-tree-level-order-traversal/
 
+> 我要打十个！
+
+看完这篇文章虽然不能打十个，但是可以迅速打五个！而且够快！
+
+
+# 102.二叉树的层序遍历 
+
+给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。
+
+<img src='../pics/102.二叉树的层序遍历.png' width=600> </img></div>
+
 ## 思路 
 
-我们之前讲过了，二叉树的深度优先遍历：[一文学通二叉树前中后序递归法与迭代法](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)
+
+接下来我们再来介绍二叉树的另一种遍历方式：层序遍历。
 
 层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。这种遍历的方式和我们之前讲过的都不太一样。
 
-需要借用一个辅助数据结构队列来实现，**队列先进先出，符合一层一层遍历的逻辑，而是用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。**
+需要借用一个辅助数据结构即队列来实现，**队列先进先出，符合一层一层遍历的逻辑，而是用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。**
 
-使用队列实现广度优先遍历，动画如下：
+**而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。**
 
+使用队列实现二叉树广度优先遍历，动画如下：
+
+![102二叉树的层序遍历.mp4](ad3d58a5-b8ee-42a5-bc89-6ad4d9e3cbf2)
 <video src='../video/102二叉树的层序遍历.mp4' controls='controls' width='640' height='320' autoplay='autoplay'> Your browser does not support the video tag.</video></div>
 
 这样就实现了层序从左到右遍历二叉树。
 
-代码如下：这份代码也可以作为二叉树层序遍历的模板。
+代码如下：**这份代码也可以作为二叉树层序遍历的模板，以后在打四个就靠它了**。
 
 ## C++代码
 
@@ -35,7 +49,8 @@ public:
         while (!que.empty()) {
             int size = que.size();
             vector<int> 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 
+
+给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历） 
+
+<img src='../pics/107.二叉树的层次遍历II.png' width=600> </img></div>
+
+## 思路 
+
+相对于102.二叉树的层序遍历，就是最后把result数组反转一下就可以了。 
+
+## C++代码
+
+```
+class Solution {
+public:
+    vector<vector<int>> levelOrderBottom(TreeNode* root) {
+        queue<TreeNode*> que;
+        if (root != NULL) que.push(root);
+        vector<vector<int>> result;
+        while (!que.empty()) {
+            int size = que.size();
+            vector<int> 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.二叉树的右视图 
+
+给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
+
+<img src='../pics/199.二叉树的右视图.png' width=600> </img></div>
+
+## 思路
+
+层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进result数组中，随后返回result就可以了。
+
+## C++代码
+
+```
+class Solution {
+public:
+    vector<int> rightSideView(TreeNode* root) {
+        queue<TreeNode*> que;
+        if (root != NULL) que.push(root);
+        vector<int> 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.二叉树的层平均值
+
+给定一个非空二叉树, 返回一个由每层节点平均值组成的数组。 
+
+<img src='../pics/637.二叉树的层平均值.png' width=600> </img></div>
+
+## 思路 
+
+本题就是层序遍历的时候把一层求个总和在取一个均值。
+
+## C++代码
+
+```
+class Solution {
+public:
+    vector<double> averageOfLevels(TreeNode* root) {
+        queue<TreeNode*> que;
+        if (root != NULL) que.push(root);
+        vector<double> 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叉树 :
+
+
+<img src='../pics/429. N叉树的层序遍历.png' width=600> </img></div>
+
+返回其层序遍历:
+
+[   
+     [1],   
+     [3,2,4],  
+     [5,6]  
+]   
+
+
+## 思路  
+
+这道题依旧是模板题，只不过一个节点有多个孩子了 
+
+## C++代码
+
+```
+class Solution {
+public:
+    vector<vector<int>> levelOrder(Node* root) {
+        queue<Node*> que;
+        if (root != NULL) que.push(root);
+        vector<vector<int>> result;
+        while (!que.empty()) {
+            int size = que.size();
+            vector<int> 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叉树的前序遍历
+
+虽然不能一口气打十个，打五个也还行。
+
+如果非要打十个，还得找叶师傅！ 
+
+<img src='../pics/我要打十个.gif' width=600> </img></div>
+
+
+
 > 更多算法干货文章持续更新，可以微信搜索「代码随想录」第一时间围观，关注后，回复「Java」「C++」 「python」「简历模板」「数据结构与算法」等等，就可以获得我多年整理的学习资料。

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)

problems/0106.从中序与后序遍历序列构造二叉树.md

@@ -0,0 +1,495 @@
+## 题目地址 
+https://leetcode-cn.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/
+
+## 思路 
+
+首先回忆一下如何根据两个顺序构造一个唯一的二叉树，相信理论知识大家应该都清楚，就是以后序数组最后一个元素为切割点，先切中序数组，根据中序数组，反过来在切后序数组。一层一层切下去，每次后序数组最后一个元素就是节点元素。
+
+如果让我们肉眼看两个序列，画一颗二叉树的话，应该分分钟都可以画出来。
+
+流程如图：
+
+
+<img src='../pics/106.从中序与后序遍历序列构造二叉树.png' width=600> </img></div>
+
+那么代码应该怎么写呢？
+
+说道一层一层切割，就应该想到了递归。
+
+来看一下一共分几步：
+
+* 第一步：如果数组大小为零的话，说明是空节点了。
+
+* 第二步：如果不为空，那么取后序数组最后一个元素作为节点元素。 
+
+* 第三步：找到后序数组最后一个元素在后序数组的位置，作为切割点 
+
+* 第四步：切割中序数组，切成中序左数组和中序右数组 （顺序别搞反了，一定是先切中序数组）
+
+* 第五步：切割后序数组，切成后序左数组和后序右数组
+
+* 第六步：递归处理左区间和右区间
+
+不难写出如下代码：（先把框架写出来）
+
+```
+    TreeNode* traversal (vector<int>& inorder, vector<int>& 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<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);
+        // [delimiterIndex + 1, end)
+        vector<int> rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end() );
+```
+
+接下来就要切割后序数组了。
+
+首先后序数组的最后一个元素指定不能要了，这是切割点 也是 当前二叉树中间节点的元素，已经用了。
+
+后序数组的切割点怎么找？
+
+后序数组没有明确的切割元素来进行左右切割，不想中序数组有明确的切割左右，左右分开就可以了。
+
+**此时有一个很重的点，就是中序数组大小一定是和后序数组的大小相同的（这是必然）。**
+
+中序数组我们都切成了左中序数组和右中序数组了，那么后序数组就可以按照左中序数组的大小来切割，切成左后序数组和右后序数组。
+
+代码如下：
+
+```
+        // postorder 舍弃末尾元素
+        postorder.resize(postorder.size() - 1);
+
+        // 依然左闭右开，注意这里使用了左中序数组大小作为切割点
+        // [0, leftInorder.size)
+        vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
+        // [leftInorder.size(), end)
+        vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());
+```
+
+此时，中序数组切成了左中序数组和右中序数组，后序数组切割成序数组和右后序数组。
+
+接下来可以递归了，代码如下：
+
+```
+        root->left = traversal(leftInorder, leftPostorder);
+        root->right = traversal(rightInorder, rightPostorder);
+```
+
+完整代码如下：
+
+## C++ 完整代码 
+
+```
+class Solution {
+private:
+    TreeNode* traversal (vector<int>& inorder, vector<int>& 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<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);
+        // [delimiterIndex + 1, end)
+        vector<int> rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end() );
+
+        // postorder 舍弃末尾元素
+        postorder.resize(postorder.size() - 1);
+
+        // 切割后序数组
+        // 依然左闭右开，注意这里使用了左中序数组大小作为切割点
+        // [0, leftInorder.size)
+        vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
+        // [leftInorder.size(), end)
+        vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());
+
+        root->left = traversal(leftInorder, leftPostorder);
+        root->right = traversal(rightInorder, rightPostorder);
+
+        return root;
+    }
+public:
+    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
+        if (inorder.size() == 0 || postorder.size() == 0) return NULL;
+        return traversal(inorder, postorder);
+    }
+};
+
+```
+
+相信大家自己就算是思路清晰， 代码写出来一定是各种问题，所以一定要加日志来调试，看看是不是按照自己思路来切割的，不要大脑模拟，那样越想越糊涂。
+
+加了日志的代码如下：（加了日志的代码不要在leetcode上提交，容易超时）
+
+
+```
+class Solution {
+private:
+    TreeNode* traversal (vector<int>& inorder, vector<int>& 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<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);
+        vector<int> rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end() );
+
+        postorder.resize(postorder.size() - 1);
+
+        vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
+        vector<int> 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<int>& inorder, vector<int>& 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<int>& inorder, int inorderBegin, int inorderEnd, vector<int>& 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<int>& inorder, vector<int>& 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<int>& inorder, int inorderBegin, int inorderEnd, vector<int>& 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<int>& inorder, vector<int>& 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<int>& inorder, int inorderBegin, int inorderEnd, vector<int>& 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<int>& preorder, vector<int>& 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<int>& inorder, int inorderBegin, int inorderEnd, vector<int>& 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<int>& preorder, vector<int>& inorder) {
+        if (inorder.size() == 0 || preorder.size() == 0) return NULL;
+
+        // 参数坚持左闭右开的原则
+        return traversal(inorder, 0, inorder.size(), preorder, 0, preorder.size());
+    }
+};
+```

problems/0429.N叉树的层序遍历.md

@@ -0,0 +1,35 @@
+
+## 题目地址 
+https://leetcode-cn.com/problems/sum-of-left-leaves/
+
+## 思路 
+
+层序遍历，和 102题目一个套路
+
+## C++代码 
+
+```
+class Solution {
+public:
+    vector<vector<int>> levelOrder(Node* root) {
+        queue<Node*> que;
+        if (root != NULL) que.push(root);
+        vector<vector<int>> result;
+        while (!que.empty()) {
+            int size = que.size();
+            vector<int> 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;
+
+    }
+};
+```

problems/0589.N叉树的前序遍历.md

@@ -0,0 +1,56 @@
+## 题目地址 
+https://leetcode-cn.com/problems/n-ary-tree-preorder-traversal/
+
+## 思路 
+
+
+
+## 递归C++代码
+
+```
+class Solution {
+private:
+    vector<int> 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<int> preorder(Node* root) {
+        result.clear();
+        traversal(root);
+        return result;
+    }
+};
+```
+
+## 迭代法C++代码
+
+```
+class Solution {
+
+public:
+    vector<int> preorder(Node* root) {
+        vector<int> result;
+        if (root == NULL) return result;
+        stack<Node*> 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;
+    }
+};
+```

problems/0590.N叉树的后序遍历.md

@@ -0,0 +1,54 @@
+## 题目地址 
+https://leetcode-cn.com/problems/n-ary-tree-postorder-traversal/
+## 思路 
+
+## 递归C++代码
+
+```
+class Solution {
+private:
+    vector<int> 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<int> postorder(Node* root) {
+        result.clear();
+        traversal(root);
+        return result;
+
+    }
+};
+```
+
+## 迭代法C++代码
+
+```
+class Solution {
+public:
+    vector<int> postorder(Node* root) {
+        vector<int> result;
+        if (root == NULL) return result;
+        stack<Node*> 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;
+    }
+};
+```