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

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

题目描述

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

【注意】

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

例如，给出

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

  3
  / \
 9  20
    /  \
   15  7

【难度】

 中等

解题

中序遍历与后序遍历序列的特点

    中序遍历顺序是左节点→父节点→右节点，后序遍历顺序是左节点→右节点→父节点。所以：

• 特点1：后序遍历序列的最后一个位置是根节点
• 特点2：中序遍历序列中，左右子树被父节点分开
• 特点3：后序遍历序列也可以分为左子树和右子树两部分（不包括最后父节点）
      在了解到上面所述的特点之后，才方便解题：
      有中序遍历序列：9-3-15-20-7和后序遍历序列9-15-7-20-3;
      根据特点1我们知道3是根节点，[9-15-7-20]是左右子树序列：

   9-15-7-20  3

    根据特点2可以知道[9]是左子树，[15-20-7]是右子树，且都各自满足中序遍历顺序：

         3

   9           15-20-7

    根据特点3，再结合特点2的结果，可以知道前1个是左子树部分，后3个是右子树部分，即[9]是左子树，[15-20-7]是右子树，且都各自满足后序遍历顺序：

   9            15-7-20  3

    再看各个子树，[9]是当前子树的根节点，没有子节点，因此也是叶节点：

  9

    根据后序遍历结果，20是当前子树的父节点：

  12-7    20

    根据中序遍历结果，15是左节点，7是右节点：

      20
  15      7

    因此我们可以总结出大致流程，根据后序遍历结果确认父节点，然后在中序遍历结果中找到父节点位置，该节点左边为左子树，右边为右子树。然后根据左子树和右子树的划分，确定后序遍历结果中左子树部分和右子树部分。随后对左子树和右子树采用相同的策略直到将整个树划分完毕，是一种分治方法。

递归

/**
 * 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:
    int v_size;
    TreeNode *buildTree(vector<int>& inorder, vector<int>& postorder, int in_l, int in_r, int post_l, int post_r){
        if (in_r < in_l)
            return NULL;
        TreeNode *cur_node = new TreeNode(postorder[post_r]);
        int root_pos;
        for (root_pos=in_l; root_pos<=in_r;++root_pos){
            if (inorder[root_pos] == postorder[post_r])
                break;
        }
        cur_node->left = buildTree(inorder, postorder, in_l, root_pos-1, post_l, post_l+root_pos-1-in_l);
        cur_node->right = buildTree(inorder, postorder, root_pos+1, in_r, post_l+root_pos-in_l, post_r-1);
        return cur_node;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        v_size = inorder.size();
        if (v_size <=0)
            return NULL;
        return buildTree(inorder, postorder, 0, v_size-1, 0, v_size-1);
    }
};

中序遍历与后序遍历序列的特点的另一种描述

    已知后序遍历最后一个节点是根节点，那逆序整个遍历结果对应的树的哪些位置呢？对于中序遍历又是怎样的结果？
    后序遍历的最后一个节点是根节点，那倒数第二个呢？

    如果根节点存在右子树，那倒数第二个节点就是右子节点，如果不存在右子树，那倒数第二个节点是左子节点。

    考虑到一般情况，后序遍历序列中，该节点前一个位置对应的节点是哪个？

    如果该节点存在右子节点，则前面节点为右子节点；
    如果该节点只有左子节点，则前面节点为左子节点；
    如果该节点没有子节点，那么前面节点应该是其“上面”节点中某一结点的左子节点。

    以题目中树结构为例

  3
  / \
 9  20
    /  \
   15  7

    后续遍历结果为[9,15,7,20,3]。3是根节点，20为3的右子节点，7是20的右子节点，7没有子节点，15是20的左子节点，15也没有子节点，9是3的左子节点。
    这里也反应一个小规律，逆序后序遍历序列对应于树的访问顺序是：从根节点出发沿最右方向遍历，直到最右边的节点，随后若当前节点存在左子节点，则访问左子节点对应的子树，若不存在，则返回到父节点，判断是否存在左子树，以此类推。
    那有两个问题，逆序后序遍历序列时，怎么判断已经到达最右边节点？又如何判断当前节点不存在左子节点？借助中序遍历结果。又因为逆序后序遍历序列时可能需要返回到父节点，所以再借助stack，以下是思路过程

1. 可以根据后序遍历结果确定根节点。
2. i指向后序遍历序列的倒数第二个位置，j指向中序遍历序列的最后一个位置。i不断递减，将经过的元素压如stack，直到stack栈顶元素与j指向元素值相同时停下。因为j代表最右边节点，所以说明此时已经到达最右边节点。
3. 如果最右边节点不存在左子节点，那么j前一位置元素应该是其父节点，也就是stack中栈顶下面那个元素。因此只要j指向元素与栈顶元素相同，则不断递减j，同时弹出栈顶元素。
4. 如果弹出过程中，栈顶元素与j位置元素不等或栈为空，则说明j位置元素时弹出前栈顶元素的左子节点。

以下是代码：

迭代

/**
 * 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>& inorder, vector<int>& postorder) {
        size_t p_size = postorder.size();
        if (p_size<=0)
            return NULL;
        
        TreeNode *root = new TreeNode(postorder[p_size-1]);
        stack<TreeNode *> nodes;
        nodes.push(root);
        
        for (int i = p_size-2, j = p_size-1; i >= 0; --i){
            if (inorder[j]!=nodes.top()->val){
                TreeNode *new_node = new TreeNode(postorder[i]);
                nodes.top()->right = new_node;
                nodes.push(new_node);
                continue;
            }
            
            TreeNode *p_node = NULL;
            while (!nodes.empty() && inorder[j] == nodes.top()->val){
                p_node = nodes.top();
                nodes.pop();
                --j;
            }
            
            p_node->left = new TreeNode(postorder[i]);
            nodes.push(p_node->left);
        }
        
        return root;
    }
};