DAY18 二叉树5

513.找树左下角的值

力扣题目链接(opens new window)

题干：给定一个二叉树，在树的最后一行找到最左边的值。

示例 1:

示例 2:

我的思路：使用 层序遍历，然后取出最后一层中的第一个元素，该元素即为所求。——我的思路对应着迭代法

卡子哥思路：本地递归偏难，反而迭代简单属于模板题

一、递归法

我们来分析一下题目：在树的最后一行找到最左边的值。

首先要是最后一行，然后是最左边的值。

如果使用递归法，如何判断是最后一行呢，其实就是深度最大的叶子节点一定是最后一行。

那么如何找最左边的呢？可以使用前序遍历（当然中序，后序都可以，因为本题没有 中间节点的处理逻辑，只要左优先就行），保证优先左边搜索（反正左侧没有的话，就会去遍历右侧了），然后记录深度最大的叶子节点，此时就是树的最后一行最左边的值。

递归三部曲：

1.确定递归函数的参数和返回值

参数必须有要遍历的树的根节点，还有就是一个int型的变量用来记录最长深度。 这里就不需要返回值了，所以递归函数的返回类型为void。

本题还需要类里的两个全局变量，maxDepth用来记录最大深度，result记录最大深度最左节点的数值。

代码如下：

 int maxDepth = INT_MIN;   // 全局变量 记录最大深度，初始化为int类型的最小值
 int result;       // 全局变量 最大深度最左节点的数值
 void traversal(TreeNode* root, int depth)

2.确定终止条件

当遇到叶子节点的时候，就需要统计一下最大的深度了，所以需要遇到叶子节点来更新最大深度。

代码如下：

 if (root->left == NULL && root->right == NULL) //遍历到了叶子节点
 {
     if (depth > maxDepth) //在同一层的叶子结点中，由于递归是先坐后右的，所以一定是同一层中的最左边的叶子节点的值被存入result，而同一层的叶子节点由于depth和这一次最左边的结点一样，所以不会造成maxDepth和result的更新！！
     {
         maxDepth = depth;           // 更新最大深度
         result = root->val;   // 最大深度那一层的最左面的数值（需要重点理解）
     }
     return;
 }

3.确定单层递归的逻辑

在找最大深度的时候，递归的过程中依然要使用回溯，代码如下：

                     // 中（因为是空实现，所以写哪里都可以）
 if (root->left) {   // 左
     depth++; // 深度加一
     traversal(root->left, depth);
     depth--; // 回溯，深度减一
 }
 if (root->right) { // 右
     depth++; // 深度加一
     traversal(root->right, depth);
     depth--; // 回溯，深度减一
 }
 return;

完整代码如下：

 class Solution {
 public:
     int maxDepth = INT_MIN;
     int result;
     void traversal(TreeNode* root, int depth) {
         if (root->left == NULL && root->right == NULL) {//递归出口
             if (depth > maxDepth) {
                 maxDepth = depth;
                 result = root->val;
             }
             return;
         }
         if (root->left) {
             depth++;
             traversal(root->left, depth);
             depth--; // 回溯
         }
         if (root->right) {
             depth++;
             traversal(root->right, depth);
             depth--; // 回溯
         }
         return;
     }
     int findBottomLeftValue(TreeNode* root) {
         traversal(root, 0);
         return result;
     }
 };

当然回溯的地方可以精简，精简代码如下：

 class Solution {
 public:
     int maxDepth = INT_MIN;
     int result;
     void traversal(TreeNode* root, int depth) {
         if (root->left == NULL && root->right == NULL) {
             if (depth > maxDepth) {
                 maxDepth = depth;
                 result = root->val;
             }
             return;
         }
         if (root->left) {
             traversal(root->left, depth + 1); // 隐藏着回溯
         }
         if (root->right) {
             traversal(root->right, depth + 1); // 隐藏着回溯
         }
         return;
     }
     int findBottomLeftValue(TreeNode* root) {
         traversal(root, 0);
         return result;
     }
 };

二、迭代法

本题使用层序遍历再合适不过了，比递归要好理解得多！

只需要记录最后一行第一个节点的数值就可以了。

代码如下：

 class Solution {
 public:
     int findBottomLeftValue(TreeNode* root) {
         queue<TreeNode*> que;
         if (root != NULL) que.push(root);
         int result = 0;
         while (!que.empty()) {
             int size = que.size();
             for (int i = 0; i < size; i++) {
                 TreeNode* node = que.front();
                 que.pop();
                 if (i == 0) result = node->val; // 记录每一一行第一个元素，经过不断迭代，最后记录的就是最后一层的最左边的元素了
                 if (node->left) que.push(node->left);
                 if (node->right) que.push(node->right);
             }
         }
         return result;
     }
 };

题集：路径总和

112. 路径总和

力扣题目链接(opens new window)

给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。

说明: 叶子节点是指没有子节点的节点。

示例: 给定如下二叉树，以及目标和 sum = 22，

返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2

我的思路：完全没有思路，只能想到暴力

卡子哥：用递归法的时候一定要确定遍历顺序！ 这道题也不涉及中结点的处理逻辑，所以用前中后序遍历都行。

很多二叉树的题目就是规则很简单，但是提笔的时候代码很难写。

这个题目里面我们遍历的时候只要找到一个符合题意的路径就立刻返回。

遍历的时候把遇到的结点的值给加起来，最后在和传入的目标值进行比较看相不相同是一种思路；但是传入目标值，在遍历的时候没遇到一个结点就用目标值减去结点值，最后看看有没有在某个叶子节点处，总体值减为了0；

一、递归

1.确定递归函数的参数和返回类型

参数：需要二叉树的根节点，还需要一个计数器，这个计数器用来计算二叉树的一条边之和是否正好是目标和，计数器为int型。

再来看返回值，递归函数什么时候需要返回值？什么时候不需要返回值？这里总结如下三点：

• 如果需要搜索整棵二叉树且不用处理递归返回值，递归函数就不要返回值。（这种情况就是本文下半部分介绍的113.路径总和ii）

• 如果需要搜索整棵二叉树且需要处理递归返回值，递归函数就需要返回值。 （这种情况我们在236. 二叉树的最近公共祖先 (opens new window)中介绍）

• 如果要搜索其中一条符合条件的路径，那么递归一定需要返回值，因为遇到符合条件的路径了就要及时返回。（本题的情况）

而本题我们要找一条符合条件的路径，所以递归函数需要返回值，及时返回，那么返回类型是什么呢？

如图所示：

图中可以看出，遍历的路线，并不要遍历整棵树，所以递归函数需要返回值，可以用bool类型表示。

所以代码如下：

 bool traversal(treenode* cur, int count)   // 注意函数的返回类型

2.确定终止条件

首先计数器如何统计这一条路径的和呢？

不要去累加然后判断是否等于目标和，那么代码比较麻烦，可以用递减，让计数器count初始为目标和，然后每次减去遍历路径节点上的数值。

如果最后count == 0，同时到了叶子节点的话，说明找到了目标和。return true

如果遍历到了叶子节点，count不为0，就是没找到，return false。

递归终止条件代码如下：

 if (!cur->left && !cur->right && count == 0) return true; // 遇到叶子节点，并且计数为0
 if (!cur->left && !cur->right) return false; // 遇到叶子节点而没有找到合适的边，直接返回false（这个if里面的判断条件不用写count！= 0了，因为如果count == 0的话就直接进入到第一个if里面了）

3.确定单层递归的逻辑

因为终止条件是判断叶子节点，所以递归的过程中就不要让空节点进入递归了。

递归函数是有返回值的，如果递归函数返回true，说明找到了合适的路径，应该立刻返回。

代码如下：

 if (cur->left) { // 左 （空节点不遍历）
     // 遇到叶子节点返回true，则直接返回true
     if (traversal(cur->left, count - cur->left->val)) return true; // 注意这里有回溯的逻辑
 }
 if (cur->right) { // 右 （空节点不遍历）
     // 遇到叶子节点返回true，则直接返回true
     if (traversal(cur->right, count - cur->right->val)) return true; // 注意这里有回溯的逻辑
 }
 return false;

以上代码中是包含着回溯的，没有回溯，如何后撤重新找另一条路径呢。

回溯隐藏在traversal(cur->left, count - cur->left->val)这里， 因为把count - cur->left->val 直接作为参数传进去，函数结束，count的数值没有改变。

为了把回溯的过程体现出来，可以改为如下代码：

 if (cur->left) { // 左
     count -= cur->left->val; // 递归，处理节点;
     if (traversal(cur->left, count)) return true;
     count += cur->left->val; // 回溯，撤销处理结果
 }
 if (cur->right) { // 右
     count -= cur->right->val;
     if (traversal(cur->right, count)) return true;
     count += cur->right->val;
 }
 return false;//如果经过上面两个if的判断都没发现加和=sum的路径，那么最终结果肯定是false

整体代码如下：

 class Solution {
 private:
     bool traversal(TreeNode* cur, int count) 
     {
         if (!cur->left && !cur->right && count == 0) return true; // 遇到叶子节点，并且计数为0
         if (!cur->left && !cur->right) return false; // 遇到叶子节点，计数不为0，直接返回false
 ​
         if (cur->left) { // 左
             count -= cur->left->val; // 递归，处理节点;
             if (traversal(cur->left, count)) return true;
             count += cur->left->val; // 回溯，撤销处理结果
         }
         if (cur->right) { // 右
             count -= cur->right->val; // 递归，处理节点;
             if (traversal(cur->right, count)) return true;
             count += cur->right->val; // 回溯，撤销处理结果
         }
         return false;//回溯到根节点了都没有一个路径返回true，那么最终结果肯定是false
     }
 ​
 public:
     bool hasPathSum(TreeNode* root, int sum) {
         if (root == NULL) return false;
         return traversal(root, sum - root->val);
     }
 };

以上代码精简之后如下：

 class Solution {
 public:
     bool hasPathSum(TreeNode* root, int sum) 
     {
         if (!root) return false;
         if (!root->left && !root->right && sum == root->val) 
         {
             return true;
         }
         return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val);
     }
 };

是不是发现精简之后的代码，已经完全看不出分析的过程了，所以我们要把题目分析清楚之后，再追求代码精简。 这一点我已经强调很多次了！

二、迭代（一刷没看）

如果使用栈模拟递归的话，那么如果做回溯呢？

此时栈里一个元素不仅要记录该节点指针，还要记录从头结点到该节点的路径数值总和。

c++就我们用pair结构来存放这个栈里的元素。

定义为：pair<TreeNode*, int> pair<节点指针，路径数值>

这个为栈里的一个元素。

如下代码是使用栈模拟的前序遍历，如下：（详细注释）

 class solution {
 ​
 public:
     bool haspathsum(TreeNode* root, int sum) {
         if (root == null) return false;
         // 此时栈里要放的是pair<节点指针，路径数值>
         stack<pair<TreeNode*, int>> st;
         st.push(pair<TreeNode*, int>(root, root->val));
         while (!st.empty()) {
             pair<TreeNode*, int> node = st.top();
             st.pop();
             // 如果该节点是叶子节点了，同时该节点的路径数值等于sum，那么就返回true
             if (!node.first->left && !node.first->right && sum == node.second) return true;
 ​
             // 右节点，压进去一个节点的时候，将该节点的路径数值也记录下来
             if (node.first->right) {
                 st.push(pair<TreeNode*, int>(node.first->right, node.second + node.first->right->val));
             }
 ​
             // 左节点，压进去一个节点的时候，将该节点的路径数值也记录下来
             if (node.first->left) {
                 st.push(pair<TreeNode*, int>(node.first->left, node.second + node.first->left->val));
             }
         }
         return false;
     }
 };

如果大家完全理解了本题的递归方法之后，就可以顺便把leetcode上113. 路径总和ii做了

113. 路径总和ii

力扣题目链接(opens new window)

给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。

说明: 叶子节点是指没有子节点的节点。

示例: 给定如下二叉树，以及目标和 sum = 22，

思路

113.路径总和ii要遍历整个树，找到所有路径，所以递归函数不要返回值！

如图：

为了尽可能的把细节体现出来，我写出如下代码（这份代码并不简洁，但是逻辑非常清晰）

 class solution {
 private:
     vector<vector<int>> result;//存放所有符合题意的路径的结果集数组
     vector<int> path;
     // 递归函数不需要返回值，因为我们要遍历整个树
     void traversal(TreeNode* cur, int count) {
         if (!cur->left && !cur->right && count == 0) { // 遇到了叶子节点且找到了和为sum的路径
             result.push_back(path);//将符合题意的结果集加入数组中
             return;
         }
 ​
         if (!cur->left && !cur->right) return ; // 遇到叶子节点而没有找到合适的边，直接返回（因为如果没有进入到上一个if判断中，则证明这个叶子节点上的count不等于0）
 ​
         if (cur->left) { // 左 （空节点不遍历）
             path.push_back(cur->left->val);
             count -= cur->left->val;
             traversal(cur->left, count);    // 递归
             count += cur->left->val;        // 回溯
             path.pop_back();                // 回溯
         }
         if (cur->right) { // 右 （空节点不遍历）
             path.push_back(cur->right->val);
             count -= cur->right->val;
             traversal(cur->right, count);   // 递归
             count += cur->right->val;       // 回溯
             path.pop_back();                // 回溯
         }
         return ;
     }
 ​
 public:
     vector<vector<int>> pathSum(TreeNode* root, int sum) {
         result.clear();
         path.clear();
         if (root == NULL) return result;
         path.push_back(root->val); // 把根节点放进路径
         traversal(root, sum - root->val);
         return result;
     }
 };

至于113. 路径总和ii 的迭代法我并没有写，用迭代方式记录所有路径比较麻烦，也没有必要，如果大家感兴趣的话，可以再深入研究研究

106.从中序与后序遍历序列构造二叉树

力扣题目链接(opens new window)

根据一棵树的中序遍历与后序遍历构造二叉树。

注意: 你可以假设树中没有重复的元素。

例如，给出

• 中序遍历 inorder = [9,3,15,20,7]

• 后序遍历 postorder = [9,15,7,20,3] 返回如下的二叉树：

我第一次看的时候一头雾水，完全没有思路。

思路：

• 中间结点和根节点用后序遍历来判断——》因为根节点就是后序遍历中的最后一个元素；而中间结点就是每次切割出来的部分中最后一个元素；

• 左节点就用中序遍历来判断——》因为根节点的左子树就是中序遍历序列中刚刚用后序遍历找到的根节点元素左边的所有元素；找到左子树包含的结点元素后，又可以对中序遍历的序列进行切割，将根节点的左子树和右子树分开！然后依次进行以上操作。

说到一层一层切割，就应该想到了递归。

来看一下一共分几步：

• 第一步：如果数组大小为零的话，说明是空节点了。

• 第二步：如果不为空，那么取后序数组最后一个元素作为节点元素。

• 第三步：找到后序数组最后一个元素在中序数组的位置，作为切割点

• 第四步：切割中序数组，切成中序左数组和中序右数组 （顺序别搞反了，一定是先切中序数组）

• 第五步：切割后序数组，切成后序左数组和后序右数组

• 第六步：递归处理左区间和右区间

不难写出如下代码：（先把框架写出来）

 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;
 }

难点大家应该发现了，就是如何切割，以及边界值找不好很容易乱套。

此时应该注意确定切割的标准，是左闭右开，还有左开右闭，还是左闭右闭，这个就是不变量，要在递归中保持这个不变量。

在数组：每次遇到二分法，都是一看就会，一写就废 (opens new window)和数组：这个循环可以转懵很多人！ (opens new window)中都强调过循环不变量的重要性，在二分查找以及螺旋矩阵的求解中，坚持循环不变量非常重要，本题也是。

首先要切割中序数组（切割点在后序数组的最后一个元素，就是用这个元素来切割中序数组的，所以必要先切割中序数组）

中序数组相对比较好切，找到切割点（后序数组的最后一个元素）在中序数组的位置，然后切割，如下代码中我坚持左闭右开的原则：

 // 找到中序遍历的切割点
 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);
     }
 };

相信大家自己就算是思路清晰， 代码写出来一定是各种问题，所以一定要加日志来调试，看看是不是按照自己思路来切割的，不要大脑模拟，那样越想越糊涂。而且这样有利于debug！！！

加了日志的代码如下：（加了日志的代码不要在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上提交，容易超时）

如果是中序和前序，同理，前序遍历序列中第一个元素是中，拿着这个中间结点在u去切割中序遍历！然后和上面的思路一样，也可以确定一颗唯一的二叉树！

前序和后序遍历是不能确定唯一一颗二叉树的！因为虽然我们找得到中间结点，但是我们找不到左子树和右子树的左右分割点！

可以看到这两个截然不同的二叉树的前序遍历和后序遍历一模一样！

105.从前序与中序遍历序列构造二叉树

力扣题目链接(opens new window)

根据一棵树的前序遍历与中序遍历构造二叉树。

注意: 你可以假设树中没有重复的元素。

例如，给出

前序遍历 preorder = [3,9,20,15,7] 中序遍历 inorder = [9,3,15,20,7] 返回如下的二叉树：

思路

本题和106是一样的道理。

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());
     }
 };

1