Leetcode 105&106 重建二叉树 前序中序后序得到层序遍历结果

前序+中序

• 前序遍历是从左往右，从根结点到叶结点，优先把父亲结点遍历出来
• 中序遍历可以给定结点，知道左右子树是什么
• 由于每个值是unique的，可以以它为键，建立映射表
• 根据前序遍历知道根结点索引index，映射表映射出根结点在中序遍历的位置index_in，然后再分别建立左右子树：
  • 左子树的根结点就是前序遍历索引index+1，理由是「前序遍历从左到右进行」
  • 右子树的根结点是 (index+1 + index_in-start_in) ，start_in是构建当前树中，中序遍历索引的起点。 index_in-start_in就是当前根结点左子树总共的结点数，它加上前序遍历的索引，就自然是右子树的根结点了，理由仍是 「前序遍历从左到右进行」

/**
 * 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:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        pre = preorder;
        for(int i=0; i<inorder.size(); i++)
            dic[inorder[i]] = i;
        return buildTreeDFS(0,0, inorder.size()-1);
    }
    
private:
    unordered_map<int, int> dic;
    vector<int> pre;
    TreeNode* buildTreeDFS(int pre_root_i, int l_in, int r_in){
        if(l_in>r_in) return NULL;
        int min_index_in = dic[pre[pre_root_i]];
        TreeNode* node = new TreeNode(pre[pre_root_i]);
        node->left = buildTreeDFS(pre_root_i+1,l_in, min_index_in-1);
        node->right = buildTreeDFS(min_index_in-l_in+pre_root_i+1, min_index_in+1, r_in);
        return node;
    }
};

后序+中序

• 方法跟前者类似，后序遍历是从右往左遍历。根结点从右往左去求

/**
 * 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:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        post = postorder;
        for(int i=0; i<inorder.size(); i++){
            dic[inorder[i]] = i;
        }
        return dfs(postorder.size()-1, 0, inorder.size()-1);
    }
private:
    unordered_map<int, int> dic;
    vector<int> post;
    TreeNode* dfs(int post_i, int in_l, int in_r){
        if(in_l > in_r) return NULL;
        int in_mid = dic[post[post_i]];
        TreeNode* node = new TreeNode(post[post_i]);
        node->left = dfs(post_i-1-(in_r - in_mid), in_l, in_mid-1);
        node->right = dfs(post_i-1, in_mid+1, in_r);
        return node;
    }
};