重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

---

C++

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

//输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。
//假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
//例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

class Solution {
public:
    struct TreeNode* reConstructBinaryTree(std::vector<int> pre,std::vector<int> in) {

             //首先判断序列是否为空，如果为空，则表示当前为空树，返回空
     if (in.size() == 0 || pre.size() == 0)
     {
         return NULL;
     }

     //提取前序遍历中的根节点，构建根节点
     struct TreeNode *root=new TreeNode(pre[0]);

     //从前序和中序序列表中，提取该节点前后的序列
     //构建该根节点的左右子树节点，首先查找该根节点的在中序遍历位置
     int i = 0;
     //如果不为空，则根据以下规则进行判断。首先查看前序遍历，第一个节点肯定为根节点，root节点，此时根据节点的关键字查看中序遍历列表中的位置，如果全部在左边，则表示该树
     //只有左子树，全部在右边，表示该树只有右子树，两边都有，说明左右子树都存在
     while (in[i] != pre[0])
     {
         i++;
     }

     //根据当前节点的位置，将节点分成两部分，将前序和中序遍历的列表分为两部分，一部分是是左子树的，一部分是右子树的，分别作为参数进行递归
     std::vector<int> preLeftList;
     std::vector<int> preRightList;
     std::vector<int> inLeftList;
     std::vector<int> inRightList;

     //提取左子树
     for (int j = 0; j < i; j++)
     {
         preLeftList.push_back(pre[j+1]);
         inLeftList.push_back(in[j]);
     }

     //提取右子树
     for (int j = i+1; j < in.size(); j++)
     {
         preRightList.push_back(pre[j]);
         inRightList.push_back(in[j]);
     }

     root->left = reConstructBinaryTree(preLeftList, inLeftList);
     root->right = reConstructBinaryTree(preRightList, inRightList);

     return root;        
    }
};

---

Java

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
   public static TreeNode reConstructBinaryTree(int[] pre, int[] in)
    {
        if(pre == null || in == null || pre.length == 0 || in.length == 0)
            return null;
        TreeNode root = reConstructBinaryTree(pre, 0, pre.length - 1, in, 0, in.length-1);
        return root;
    }

    private static TreeNode reConstructBinaryTree(int[] pre,int startPre, int endPre,int[] in, int startIn, int endIn)
    {
        if(startPre > endPre || startIn > endIn)
            return null;

        TreeNode root = new TreeNode(pre[startPre]);

        //search for root node in in[]
        int rootIn = 0;
        for(; rootIn < in.length; rootIn++)
        {
            if(in[rootIn] == root.val)
                break;
        }
        int leftlength = rootIn - startIn;
        int rightlength = endIn - rootIn;
        if(leftlength > 0)
            root.left = reConstructBinaryTree(pre, startPre+1, startPre+leftlength, in, startIn, rootIn-1);
        if(rightlength > 0)
            root.right = reConstructBinaryTree(pre, startPre+leftlength+1, endPre, in, rootIn+1, endIn);


        return root;
    }

}

---

Python

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回构造的TreeNode根节点
    def reConstructBinaryTree(self, preorder, inorder):
        # write code here
        if not preorder or not inorder:
            return
        root = TreeNode(preorder[0])
        i = inorder.index(preorder[0])
        root.left = self.reConstructBinaryTree(preorder[1:i+1], inorder[:i])
        root.right = self.reConstructBinaryTree(preorder[i+1:], inorder[i+1:])
        return root