leet105. 从前序与中序遍历序列构造二叉树 &106. 从中序与后序遍历序列构造二叉树& STL vector拓展_V2 & unordered_map

题目

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

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

例如，给出

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

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

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

例如，给出

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

通过次数89,442提交次数125,630

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

前言
二叉树前序遍历的顺序为：
先遍历根节点；
随后递归地遍历左子树；
最后递归地遍历右子树。

二叉树中序遍历的顺序为：
先递归地遍历左子树；
随后遍历根节点；
最后递归地遍历右子树。

二叉树的后序遍历的顺序为：
先递归地遍历左子树；
在递归地遍历右子树：
随后遍历根节点；

在「递归」地遍历某个子树的过程中，我们也是将这颗子树看成一颗全新的树，按照上述的顺序进行遍历。

思路一

对于任意一颗树而言，前序遍历的形式总是

[ 根节点, [左子树的前序遍历结果], [右子树的前序遍历结果] ]

即根节点总是前序遍历中的第一个节点。而中序遍历的形式总是

[ [左子树的中序遍历结果], 根节点, [右子树的中序遍历结果] ]

后续的遍历形式：

[[左子树的后序遍历结果],[右子树的后序遍历结果]，根节点]

只要我们在中序遍历中定位到根节点，那么我们就可以分别知道左子树和右子树中的节点数目。由于同一颗子树的前序遍历和中序遍历的长度显然是相同的，因此我们就可以对应到前序遍历的结果中，对上述形式中的所有左右括号进行定位。

这样以来，我们就知道了左子树的前序遍历和中序遍历结果，以及右子树的前序遍历和中序遍历结果，我们就可以递归地对构造出左子树和右子树，再将这两颗子树接到根节点的左右位置。

同理：知道后序遍历和中序遍历结果，也可唯一构造一棵二叉树，但是前序+后序 无法实现。

拓展

STL vector常用方法总结

参考链接：
参考一：
参考二：
unordered_map
unordered_map:
头文件：
#include<tr1/unordered_map>
using namespace std::tr1;

常用api：

• 查找是否存在：

若有unordered_map <int, int> mp;查找x是否在map中
方法1: 若存在 mp.find(x)!=mp.end()
方法2: 若存在 mp.count(x)!=0

• 插入元素

mp.insert(Map::value_type(1,“Raoul”));

• 遍历map

unordered_map<key,T>::iterator it;
    (*it).first;   //the key value
    (*it).second   //the mapped value
    for(unordered_map<key,T>::iterator iter=mp.begin();iter!=mp.end();iter++)
          cout<<"key value is"<<iter->first<<" the mapped value is "<< iter->second;

    //也可以这样
    for(auto& v : mp)
        print v.first and v.second

• 与map对比

内部实现机理
map： map内部实现了一个红黑树，该结构具有自动排序的功能，因此map内部的所有元素都是有序的，红黑树的每一个节点都代表着map的一个元素，因此，对于map进行的查找，删除，添加等一系列的操作都相当于是对红黑树进行这样的操作，故红黑树的效率决定了map的效率。

unordered_map: unordered_map内部实现了一个哈希表，因此其元素的排列顺序是杂乱的，无序的

• 适用场景对比

map
优点：
有序性，这是map结构最大的优点，其元素的有序性在很多应用中都会简化很多的操作
红黑树，内部实现一个红黑书使得map的很多操作在的时间复杂度下就可以实现，因此效率非常的高
缺点：
空间占用率高，因为map内部实现了红黑树，虽然提高了运行效率，但是因为每一个节点都需要额外保存父节点，孩子节点以及红/黑性质，使得每一个节点都占用大量的空间
适用处，对于那些有顺序要求的问题，用map会更高效一些

unordered_map
优点：
因为内部实现了哈希表，因此其查找速度非常的快
缺点：
哈希表的建立比较耗费时间
适用处，对于查找问题，unordered_map会更加高效一些，因此遇到查找问题，常会考虑一下用unordered_map

源码

leet105

//方法一：递归
//思路
//
//对于任意一颗树而言，前序遍历的形式总是
//
//
//[根节点, [左子树的前序遍历结果], [右子树的前序遍历结果]]
//即根节点总是前序遍历中的第一个节点。而中序遍历的形式总是
//
//
//[[左子树的中序遍历结果], 根节点, [右子树的中序遍历结果]]

class Solution {
    //利用unordered_map 提高遍历效率
private:  
    unordered_map<int, int> index;
public:
    TreeNode* myBuildTree(vector<int>& preorder, int preStart, int preEnd, vector<int>& inorder, int inStart, int inEnd) {
        if (preStart > preEnd) {
            return nullptr;
        }
        //先序遍历第一个节点即为根节点
        int pre_root = preStart;
        //查找第一个节点在中序遍历中的下标位置
        int in_root = index[preorder[preStart]];
        
        //创建新的根节点
        TreeNode* root = new TreeNode(preorder[preStart]);
        
        //分割中序遍历vector,得到左子树的区间
        int in_sub_left = in_root - inStart;
        //递归的构造左子树，并连接到根节点
        //区间调整
         先序遍历中「从 左边界+1 开始的 size_left_subtree」个元素就对应了中序遍历中「从 左边界 开始到 根节点定位-1」的元素
        root->left = myBuildTree(preorder,preStart+1,preStart+in_sub_left,inorder,inStart,in_root-1);
         先序遍历中「从 左边界+1+左子树节点数目 开始到 右边界」的元素就对应了中序遍历中「从 根节点定位+1 到 右边界」的元素
        root->right =myBuildTree(preorder,preStart+in_sub_left+1,preEnd ,inorder,in_root+1,inEnd);
        return root;
    }
        TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int n = preorder.size();
        //构建哈希映射
        for (int i = 0; i < n; i++) {
            index[inorder[i]] = i;
        }

        return myBuildTree(preorder, 0, n - 1, inorder, 0, n - 1);

    }

};

leet106

/**
 * 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 {
    private:
    unordered_map<int,int> treeIndex;
public:
    TreeNode * build(vector<int>& inorder, int in_left,int in_right,vector<int>& postorder,int po_left,int po_right){
        //判断合法性
        if(po_left > po_right) return nullptr;
        //ton过后序遍历 找到根节点
        int root_val = postorder[po_right];
        //在中序遍历中找到根节点对应元素的下标
        int in_loc = treeIndex[root_val];
        //将中序遍历vector 分割，左侧区间大小为
        int in_sub_len  = in_loc -in_left;

        //创建新节点,存放根节点元素
        TreeNode * root = new TreeNode(root_val);

        //递归左右节点
        root->left = build(inorder,in_left,in_loc-1,postorder,po_left,po_left+in_sub_len-1);
        root->right = build(inorder,in_loc+1,in_right,postorder,po_left+in_sub_len,po_right-1);

        return root;

    }

    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        int len = inorder.size();
        //判断特例
        if(len == 0) return nullptr;
        //hash map 索引
        for(int i =0; i< len;i++){
            //cout << inorder[i]<<" ";
            treeIndex[inorder[i]] = i;
        }

        return build(inorder,0,len-1,postorder,0,len-1);

    }
};