《剑指Offer》之“重建二叉树”

题目描述

---

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

实现代码

---

错解：

class Solution {
public:
    TreeNode* reConstructBinaryTree(int[] pre,int[] vin) {

         int* startpre = pre;
        int* endpre = pre.length-1;
        int* startvin = vin;
        int* endvin = vin.length-1;
        return confim(startpre,endpre,startvin,endvin);
    }
    TreeNode* confim(int* startP,int* endP,int* startV, int* endV){
        int rootValue = startP[0];
        TreeNode* root = new TreeNode();
        root->val = rootValue;
        root->left = root->right = nullptr;
        if(startP == endP){
            if(startV == endV && *startP ==*startV)
                return root;
            else
                throw std:exception("x");
        }
        int* rootV = startV;
        while(rootV <= endV && *rootV!=rootValue)
            ++rootV;
        if(rootV == endV && *rootV != rootValue)
            throw std:exception("x");
        int leftLength = rootV -startV;
        int* leftPE = startP +LeftLength;
        if (leftLength > 0){
            root->left = confim(startP+1,leftPE,startV,rootV -1);
        }
        if(leftLength< endP -startP){
            root->right = confim(leftPE+1,endP,rootV+1,endV);
        }
        return root;
    }

};

---

正解

class Solution {

public:

    struct TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> in) {

        int in_size = in.size();

        if(in_size == 0)

            return NULL;

        vector<int> pre_left, pre_right, in_left, in_right;

        int val = pre[0];

        TreeNode* node = new TreeNode(val);//root node is the first element in pre

        int p = 0;

        for(p; p < in_size; ++p){

            if(in[p] == val) //Find the root position in in 

                break;

        }

        for(int i = 0; i < in_size; ++i){

            if(i < p){

                in_left.push_back(in[i]);//Construct the left pre and in 

                pre_left.push_back(pre[i+1]);

            }

            else if(i > p){

                in_right.push_back(in[i]);//Construct the right pre and in 

                pre_right.push_back(pre[i]);

            }

        }

        node->left = reConstructBinaryTree(pre_left, in_left);

        node->right = reConstructBinaryTree(pre_right, in_right);

        return node;

    }

};