leetcode

题目：Construct Binary Tree from Inorder and Postorder Traversal

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

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

题目：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.

这两道题的思路是类似的，就放在一起说了，我就说第一个题目了，第二个可以用相同的方法做，就不赘述了。

个人思路：

1、先搞清中序遍历和后序遍历的特点，中序遍历：左、根、右，后序遍历：左、右、根，可以看出后序遍历的最后一个数就是根节点的值

2、找到根节点后，可以根据根节点找出中序遍历和后序遍历中左子树节点和右子树节点的范围，然后按照相似的方法，找出左子树的根节点和右子树的根节点，它们也就是原树根节点的左右孩子，递归地往下进行即可构建完毕

代码：

#include <stddef.h>
#include <vector>

using namespace std;

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)
    {
        return build(inorder, postorder, 0, inorder.size() - 1, 0, postorder.size() - 1);
    }
private:
    TreeNode* build(vector<int> &inorder, vector<int> &postorder, int in_start, int in_end, int post_start, int post_end)
    {
        if (post_start > post_end)
        {
            return NULL;
        }

        TreeNode *root = new TreeNode(postorder[post_end]);

        //在中序遍历中找到根节点，以区分左子树和右子树
        int inorder_root;
        for (inorder_root = in_start; inorder_root <= in_end; ++inorder_root)
        {
            if (inorder[inorder_root] == postorder[post_end])
            {
                break;
            }
        }
        //中序遍历中的左子树和右子树范围
        int inorder_left_start = in_start;
        int inorder_left_end = inorder_root - 1;
        int inorder_right_start = inorder_root + 1;
        int inorder_right_end = in_end;
        //后序遍历中的左子树和右子树范围
        int postorder_left_start = post_start;
        int postorder_left_end = post_start + (inorder_root - in_start) - 1;
        int postorder_right_start = postorder_left_end + 1;
        int postorder_right_end = post_end - 1;

        root->left = build(inorder, postorder, inorder_left_start, inorder_left_end, postorder_left_start, postorder_left_end);
        root->right = build(inorder, postorder, inorder_right_start, inorder_right_end, postorder_right_start, postorder_right_end);

        return root;
    }
};

下面贴出第二道题的代码，算法类似第一题：

#include <stddef.h>
#include <vector>

using namespace std;

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)
    {
        return build(preorder, inorder, 0, preorder.size() - 1, 0, inorder.size() - 1);
    }
private:
    TreeNode* build(vector<int> &preorder, vector<int> &inorder, int pre_start, int pre_end, int in_start, int in_end)
    {
        if (pre_start > pre_end)
        {
            return NULL;
        }

        TreeNode *root = new TreeNode(preorder[pre_start]);

        //在中序遍历中找到根节点，以区分左子树和右子树
        int inorder_root;
        for (inorder_root = in_start; inorder_root <= in_end; ++inorder_root)
        {
            if (inorder[inorder_root] == preorder[pre_start])
            {
                break;
            }
        }
        //中序遍历中的左子树和右子树范围
        int inorder_left_start = in_start;
        int inorder_left_end = inorder_root - 1;
        int inorder_right_start = inorder_root + 1;
        int inorder_right_end = in_end;
        //前序遍历中的左子树和右子树范围
        int preorder_left_start = pre_start + 1;
        int preorder_left_end = preorder_left_start + (inorder_root - in_start) - 1;
        int preorder_right_start = preorder_left_end + 1;
        int preorder_right_end = pre_end;

        root->left = build(preorder, inorder, preorder_left_start, preorder_left_end, inorder_left_start, inorder_left_end);
        root->right = build(preorder, inorder, preorder_right_start, preorder_right_end, inorder_right_start, inorder_right_end);

        return root;
    }
};

网上看了几篇文章，思路都是相似的，递归地构造出树。