前（后）序+中序遍历序列构建二叉树——递归方法分析及实现

最新推荐文章于 2024-07-28 17:42:24 发布

W24-

最新推荐文章于 2024-07-28 17:42:24 发布

阅读量1.2k

点赞数 1

分类专栏：数据结构文章标签：二叉树数据结构

本文链接：https://blog.csdn.net/qq_39583450/article/details/109412109

版权

数据结构专栏收录该内容

12 篇文章 2 订阅

订阅专栏

文章目录

问题来源
从前序和中序遍历序列构建二叉树（递归解法）
从后序和中序遍历序列构建二叉树（递归解法）

问题来源

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

从前序和中序遍历序列构建二叉树（递归解法）

假定树中没有重复元素。

例如，给出

前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,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:

    unordered_map<int, int> index; // 表示每一个元素(两种遍历方式元素是相同的)在中序中出现的位置。
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int n = preorder.size();
        for(int i=0; i<n; i++) {
            index[inorder[i]] = i;
        }
        return recurBuildTree(preorder, inorder, 0, n-1, 0, n-1);
    }
    
    TreeNode* recurBuildTree(vector<int>& preorder, vector<int>& inorder, int preorder_left, int preorder_right, int inorder_left, int inorder_right) {
        if(preorder_left > preorder_right) {
            return NULL;
        }

        int root_value = preorder[preorder_left]; // 要建立根节点上的值
        int root_location_inorder = index[root_value]; // 在中序中的位置

        TreeNode* root = new TreeNode(root_value);
        int left_node_number = root_location_inorder - inorder_left; // 左子树的元素个数

        root->left = recurBuildTree(preorder, inorder, preorder_left + 1, preorder_left + left_node_number, inorder_left, root_location_inorder - 1);
        root->right = recurBuildTree(preorder, inorder, preorder_left + left_node_number + 1, preorder_right, root_location_inorder + 1, inorder_right);

        return root;

    }
};

从后序和中序遍历序列构建二叉树（递归解法）

例如，给出

中序遍历 inorder = [9,3,15,20,7]
后序遍历 postorder = [9,15,7,20,3]

返回如下的二叉树：

和的前序和中序构建二叉树很像，都是根据前序（后序）可以确定当前子树的根节点，然后在中序序列中找到该根节点的位置，其两侧分别对应左右子树的元素：

对于前序序列来说，第一个元素就是根节点；
对于后序序列来说，最后一个元素就是根节点；

由当前的中序序列，以及根节点在中序中的位置，可以确定左右两个子树的节点个数left_num, right_num，那么后序序列中前left_num个元素就是构建左子树所需要的元素，除去最后一个元素（根节点），剩下的right_num个元素就是构建右子树所需要的元素。

/**
 * 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> idx;
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        int n = inorder.size();
        for(int i=0; i<n; i++) {
            idx[inorder[i]] = i;
        }
        return recurBuildTree(inorder, postorder, 0, n-1, 0, n-1);
    }

    TreeNode* recurBuildTree(vector<int>& inorder, vector<int>& postorder, int inorder_left, int inorder_right, int postorder_left, int postorder_right) {
        if(postorder_right < postorder_left) {
            return nullptr;
        }

        int root_value = postorder[postorder_right];
        int inorder_root_location = idx[root_value];

        int left_tree_node_num = inorder_root_location - inorder_left;
        int right_tree_node_num = inorder_right - inorder_root_location;
        TreeNode* root = new TreeNode(root_value);
        
        root->left = recurBuildTree(inorder, postorder, inorder_left, inorder_root_location - 1, postorder_left, postorder_left + left_tree_node_num - 1);
        root->right = recurBuildTree(inorder, postorder, inorder_root_location + 1, inorder_right, postorder_right - right_tree_node_num, postorder_right - 1);

        return root;
    }
};

而前序+后序遍历结果是无法确定二叉树的。