Leetcode從前中後序列構建二叉樹題解算法

從前（或後）與中序序列構建二叉樹

Leetcode 106. Construct Binary Tree from Inorder and Postorder
Leetcode 105. Construct Binary Tree from Preorder and Inorder Traversal兩道題是從前中後序列回覆原二叉樹，是二叉樹數據結構常見的題型，現在分析解決下。

1. 基本思路分析

• 首先明確二叉樹的前中後序遍歷的概念。可知前序遍歷的第一個元素即根結點的關鍵字，後序遍歷的最後一個元素即根結點的關鍵字，找出了根結點，再在中序遍歷序列中確定左右子樹的序列找出，同時在對應的前或後序列中找出相應子序列，那麼重複上述思路實現根結點的左右子樹的構建。
• 只有前後序列無法確定左右子樹，故此條件無法構建原二叉樹。¹
  舉例說明，
  先序：abdgcefh—>a bdg cefh
  中序：dgbaechf---->dgb a echf

得出：a是樹根，a有左子樹和右子樹，左子樹有bdg結點，右子樹有cefh結點。
在對左右子樹遞歸上述分析，左子樹的
先序：bdg—>b dg
中序：dgb —>dg b
得出結論：d是b左子樹的根節點,d無左子樹，g是d的右子樹

2. 代碼實現

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
//從前中序構建二叉樹
TreeNode *BuildTreeFromPreorderInorder(vector<int> &preorder,
                                         vector<int> &inorder) {
    if (preorder.empty()) {
      return NULL;
    }
    int key = preorder[0];
    size_t n = preorder.size();
    TreeNode *root = new TreeNode(key);
    vector<int> l_pre, l_in, r_pre, r_in;
    int tmp = inorder[0];
    int b = 0;
    while (tmp != key) {
      l_in.push_back(tmp);
      tmp = inorder[++b];
    }
    size_t nl = l_in.size();
    for (size_t i = 0; i < nl; i++) {
      l_pre.push_back(preorder[i + 1]);
    }
    for (size_t i = b + 1; i < n; i++) {
      r_in.push_back(inorder[i]);
    }
    for (size_t i = nl + 1; i < n; i++) {
      r_pre.push_back(preorder[i]);
    }
    root->left = BuildTreeFromPreorderInorder(l_pre, l_in);
    root->right = BuildTreeFromPreorderInorder(r_pre, r_in);
    return root;
  }
  //從中後序構建二叉樹
  TreeNode *BuildTreeFromInorderPostorder(vector<int> &inorder,
                                          vector<int> &postorder) {
    if (inorder.empty()) {
      return NULL;
    }
    auto key = *(postorder.end() - 1);
    TreeNode *root = new TreeNode(key);
    // vector<int>::iterator bin = find(inorder.begin(), inorder.end(), key);
    vector<int> new_l_in, new_r_in, new_l_post, new_r_post;
    // TODO: debug
    // copy(inorder.begin(), bin, new_l_in.begin());
    int tmp = inorder[0];
    int nb = 0;
    while (tmp != key) {
      new_l_in.push_back(tmp);
      tmp = inorder[++nb];
    }
    auto n = inorder.size();
    auto num_l = new_l_in.size();
    for (size_t i = 0; i < num_l; i++) {
      new_l_post.push_back(postorder[i]);
    }
    // copy(bin + 1, inorder.end(), new_r_in.begin());
    for (size_t i = num_l; i < n - 1; i++) {
      new_r_post.push_back(postorder[i]);
    }
    for (size_t i = num_l + 1; i < n; i++) {
      new_r_in.push_back(inorder[i]);
    }
    root->left = BuildTreeFromInorderPostorder(new_l_in, new_l_post);
    root->right = BuildTreeFromInorderPostorder(new_r_in, new_r_post);
    return root;
  

3. 更快的解法

class Solution {
public:
    // use recursion to construct the tree
    // 1. use preorder to confirm the root
    // 2. use inorder to get the boundary of left subtree and right subtree
    int pIndex = 0;
    int iIndex = 0;
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if (preorder.size() == 0 || inorder.size() == 0) return NULL;
        return helper(preorder, inorder, INT_MIN);
    }
    
    // nextInorderVal: the next value after visiting the current subtree in inorder order.
    TreeNode* helper(vector<int>& preorder, vector<int>& inorder, int nextInorderVal) {
        // base case
        if (pIndex == preorder.size() || inorder[iIndex] == nextInorderVal) { return NULL; }
        
        
        // consturct the root
        TreeNode* root = new TreeNode(preorder[pIndex++]);
        root->left = helper(preorder, inorder, root->val);
        
        // inorder index
        iIndex++;
        
        root->right = helper(preorder, inorder, nextInorderVal);
        
        return root;
    }
};

---

1. https://blog.csdn.net/wumuzi520/article/details/8078322 ↩︎