105从前序与中序遍历序列构造二叉树 && 106 从中序与后序遍历序列构造二叉树 (递归 + 哈希）

引言

这两道题主要是考察二叉树遍历的掌握，即由前序和中序推出原二叉树，由后序和中序推出原二叉树，这里先来说一下推导过程；
前序和中序
知道前序遍历和中序遍历，如何推原二叉树？（直接是结论，可以自行推导一下）
1，先看前序的第一个元素first，这个元素值就是根节点的元素值
2，从中序遍历中找到该元素first，该元素左边的所有元素就是二叉树的左子树上的节点，右边的所有元素就是二叉树右子树的节点，即将中序遍历结果分为了两部分
3，单看中序遍历左边，左边所有元素谁在先序遍历前面谁就是左树的根节点，右树一样（其实就类似一直重复前两步，一个递归过程），依次类推；

后序和中序
1，先看后序的最后一个元素last，这个元素值就是根节点的元素值
2，从中序遍历中找到该元素last，该元素左边的所有元素就是二叉树的左子树上的节点，右边的所有元素就是二叉树右子树的节点，即将中序遍历结果分为了两部分
3，重复前两步直到结束

可以发现前序和后序不同就是前序是从前面开始找的，后序是从后面开始找的；

这就是知道遍历顺序来推原二叉树的过程，如果看不懂，还是建议在数据结构二叉树的遍历章节仔细研究一下，多试几个例子就会了；

有了这个基础，下面来说这两道题；

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

给定一棵树的前序遍历 preorder 与中序遍历 inorder。请构造二叉树并返回其根节点。

示例 1:

Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
Output: [3,9,20,null,null,15,7]

示例 2:
Input: preorder = [-1], inorder = [-1]
Output: [-1]

提示:

1 <= preorder.length <= 3000
inorder.length == preorder.length
-3000 <= preorder[i], inorder[i] <= 3000
preorder 和 inorder 均无重复元素
inorder 均出现在 preorder
preorder 保证为二叉树的前序遍历序列
inorder 保证为二叉树的中序遍历序列

我们已经知道如何推出原二叉树的方法，在这里用代码实现可能有点困难，我们来一一解决；
1，肯定能想到需要用到递归，我们只需要找到前序遍历的第一个节点，然后分别递归生成左子树和右子树就可以了；
2，这里主要说一点就是如何在中序遍历中找到根节点？ 这就可以用一个哈希表来快速查找到根节点的位置并返回下标；
这里就直接上代码，注释在代码里更清楚

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int posFirst;
    unordered_map<int, int> hash;
    //该函数功能就是通过前序与中序遍历序列构造二叉树
    TreeNode* helper(int posLeft, int posRight, vector<int>& preorder, vector<int>& inorder) {
        //当左右子树为空时，递归结束
        if (posLeft > posRight) 
            return NULL;

        //找到根节点的val值，并创建根节点
        int rootVal = preorder[posFirst];
        TreeNode* root = new TreeNode(rootVal);

        //找到根节点在中序遍历中的下标
        int index = hash[rootVal];

        //前序遍历的坐标向后继续，为了之后找到左右子树的根节点
        posFirst++;

        //创建左子树和右子树，必需先左后右，因为posFirst是先过左子树根节点再过右子树根节点
        root -> left = helper(posLeft, index - 1, preorder, inorder);
        root -> right = helper(index + 1, posRight, preorder, inorder);
        return root;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        posFirst = 0;
        int idx = 0;
        //将中序遍历结果存放到哈希表中，key值为val，value值为下标
        for (auto& val : inorder) {
            hash[val] = idx++;
        }
        return helper(posFirst, inorder.size() - 1, preorder, inorder);
    }
};

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

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

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

例如，给出
中序遍历 inorder = [9,3,15,20,7]
后序遍历 postorder = [9,15,7,20,3]
返回如下的二叉树：

这道题和上面几乎一模一样，唯一区分点就根节点要从后序的后面找起，还有要先建右子树，再建左子树
代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int posLast;
    unordered_map<int, int> hash;
    //该函数功能就是通过后序与中序遍历构造二叉树
    TreeNode* helper(int posLeft, int posRight, vector<int>& inorder, vector<int>& postorder) {
        //当左右子树为空时，递归结束
        if (posLeft > posRight) 
            return NULL;

        //找到根节点的val值，并创建根节点
        int rootVal = postorder[posLast];
        TreeNode* root = new TreeNode(rootVal);

        //找到根节点在中序遍历中的下标
        int index = hash[rootVal];

        //后序遍历的坐标向前继续，为了之后找到左右子树的根节点
        posLast--;

        //创建右子树和左子树，必需先右后左，因为posLast是先过右子树根节点再过左子树根节点
        root -> right = helper(index + 1, posRight, inorder, postorder);
        root -> left = helper(posLeft, index - 1, inorder, postorder);
        return root;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        posLast = (int)postorder.size() - 1;
        int idx = 0;
        //将中序遍历结果存放到哈希表中，key值为val，value值为下标
        for (auto& val : inorder) {
            hash[val] = idx++;
        }
        return helper(0, posLast, inorder, postorder);
    }
};

总结

这两道题是非常经典的二叉树遍历题目，思路比较简单，但是代码实现可能会有点困难，所以一定要熟悉二叉树的三种基本遍历，并能灵活使用哈希表来帮助过程实现；