[LeetCode] (medium) 105. Construct Binary Tree from Preorder and Inorder Traversal

https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/

Given preorder and inorder traversal of a tree, construct the binary tree.

Note:
You may assume that duplicates do not exist in the tree.

For example, given

preorder = [3,9,20,15,7]
inorder = [9,3,15,20,7]

Return the following binary tree:

    3
   / \
  9  20
    /  \
   15   7

---

从前序遍历和中序遍历重构二叉树。

递归方法：

很直接，因为针对每一个区间，前序遍历的第一个值就是树根，然后找到它在中序遍历中对应的位置（由于树中每个元素都是唯一的，所以既可以便利查找也可以预先建立map），就可以在中序遍历中把当前节点的左右子树划分开来，再把这个划分方法重新反映到前序遍历的数组中即可。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    unordered_map<int, int> M;
    
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        static int fast_io = []() { std::ios::sync_with_stdio(false); cin.tie(nullptr); return 0; }();
        if(preorder.size() == 0) return NULL;
        
        for(int i = 0; i < inorder.size(); ++i){
            M[inorder[i]] = i;
        }
        TreeNode *result = real_function(preorder, inorder, 0, preorder.size()-1, 0, inorder.size());
        return result;
        
    }
    
    TreeNode* real_function(vector<int>& preorder, vector<int>& inorder, int lo_p, int hi_p, int lo_i, int hi_i){
        if(lo_p > hi_p) return NULL;
        TreeNode *result = new TreeNode(preorder[lo_p]);
        // if(lo_p == hi_p) return result;
        
        // int cur_inorder = lo_i;
        // while(inorder[cur_inorder] != preorder[lo_p]) ++cur_inorder;
        
        int cur_inorder = M[preorder[lo_p]];
        
        result->left = real_function(preorder, inorder, lo_p+1, lo_p+(cur_inorder-lo_i), lo_i, cur_inorder-1);
        result->right = real_function(preorder, inorder, lo_p+(cur_inorder-lo_i)+1, hi_p, cur_inorder+1, hi_i);
        return result;
    }
};

迭代方法：

很难说明，总之就是利用两种遍历方法中节点访问的次序规律进行循环。或者可以理解成：前序遍历的性质使得容易找到每个子树的根，但是由于在中序中根是后访问的，所以需要暂存，同时后进先出（靠近叶子的节点在中序遍历中先访问）的规律，使用栈来存储。总之就是很巧妙。

------

2019年3月1日补充：

在百度知道中看到关于中序遍历和前序遍历的如下解释：

前序和后序在本质上都是将父节点与子结点进行分离，但并没有指明左子树和右子树的能力，因此得到这两个序列只能明确父子关系，而不能确定一个二叉树。

 同时注意到在整个算法的循环过程中，唯一的活跃节点只有栈顶结点（在执行pop操作之后旧栈顶会继续“活跃”一段时间，不过他的作用仅限于连接，而不再参与比较），所以栈顶和中序遍历的比较的目的是确定下一个前序遍历结点和当前活跃节点（栈顶，同时也是cur）的关系（是左子还是右子），如果当前结点还没有在中序遍历中遇到，就意味着它的左子树应该作为活跃子树，如果在中序遍历中遇到，则意味着其左子树已经全部处理完，转而进行右子树的处理。

而关于栈这个结构，则可理解为第一次遇到某个节点时，仅继续处理它的左子树（dfs），因此它的右子树属于悬而未解的状态，需要一会儿回过头来处理，所以需要使用栈来暂存，一旦在中序遍历中遇到，则意味着它的两个孩子都已经处理（或即将开始处理，同时我们这里只需要关注和它有直接关联的孩子，而不需要确保两个子树的整体处理完成与否），因此可以离开栈。

------

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.empty()) return NULL;
        
        stack<TreeNode*> S;
        bool right = false;
        
        int p_cnt = 0, i_cnt = 0;
            
        TreeNode *result = new TreeNode(preorder[p_cnt]);
        TreeNode *cur = result;
        ++p_cnt;
        S.push(cur);
        
        while(i_cnt < inorder.size()){
            if(!S.empty() && S.top()->val == inorder[i_cnt]){
                cur = S.top();  S.pop();
                right = true;
                ++i_cnt;
            }else{
                if(right){
                    right = false;
                    cur->right = new TreeNode(preorder[p_cnt]);
                    ++p_cnt;
                    cur = cur->right;
                    S.push(cur);
                }else{
                    cur->left = new TreeNode(preorder[p_cnt]);
                    ++p_cnt;
                    cur = cur->left;
                    S.push(cur);
                }
            }
        }
        return result;
        
    }
};