剑指Offer-- 重建二叉树

思路还是很明了的，不知道为啥就是过不去了。这是之前写的版本，有问题，后来 又写了一个版本

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        
        int rootval = pre[0];
        TreeNode* root = new TreeNode(rootval);
        return helper(root, pre, vin);
    }
    TreeNode* helper (TreeNode *preroot,vector<int> pre,vector<int> vin)
    {
        int lenL = 0,lenR = 0,i = 0,len;
        len = pre.size();        //总的长度
        
        while (vin[i++] != preroot -> val)
        {
            lenL++;              // 左子树的长度
        }
        lenR = len - lenL - 1;   // 右子树的长度
        if (len == 0|| lenL == 0 || lenR == 0)
            return nullptr;
        vector<int> preleftTree,prerightTree;   // 定义前序左子树，前序右子树
        vector<int> inleftTree,inrightTree;     // 定义中序左子树，中序右子树
        for (int m = 0,n = 0; m < lenL; m++)
        {
            preleftTree[n++] = pre[1 + m];      //构建前序左子树
        }
        for (int m = 0,n = 0; m < lenL; m++)
        {
            inleftTree[n++] = vin[m];       // 构建中序左子树
        }
        
        for (int m = 0,n = 0; m < lenR; m++)
        {
            prerightTree[n++] = pre[1 + m + lenL];// 构建前序右子树
        }
        for (int m = 0,n = 0; m < lenR; m++)
        {
            inrightTree[n++] = vin[1 + m + lenL];   // 构建中序右子树
        }
        TreeNode * leftC = new TreeNode(preleftTree[0]);
        preroot -> left = leftC;
        TreeNode * rightC = new TreeNode(prerightTree[0]);
        preroot -> right = rightC;
        helper(leftC,preleftTree,inleftTree);
        helper(rightC,prerightTree,inrightTree);
        return preroot;
    }
};

新版本如下：可以调试过去，思路还是递归去找 左子树 和 右子树。

#include <iostream>
#include <vector>
using namespace std;

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  };

    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        if (pre.size()<= 0 || vin.size() <=0)                  // pre和vin的大小应该是一样的
            return nullptr;
        int lenR = 0, lenL = 0, len, i = 0;
        len = pre.size();
        TreeNode* root = new TreeNode(pre[0]);

        while(vin[i] != root -> val)
        {
            i++;
            lenL++;
        }
        lenR = len - lenL - 1;

        vector<int> preLeftTree,preRightTree,inLeftTree,inRightTree;
        for (int j = 1; j <= lenL; j++)
        {
            preLeftTree.push_back(pre[j]);          // 构建左子树的前序排列
        }
        for (int j = 1 + lenL; j <= len - 1; j++)
        {
            preRightTree.push_back(pre[j]);        //  构建右子数的前序排列
        }

        for (int j = 0; j < lenL; j++)
        {
            inLeftTree.push_back(vin[j]);          // 构建左子树的中序排列
        }
        for (int j = 1 + lenL; j <= len - 1; j++)
        {
            inRightTree.push_back(vin[j]);        //  构建右子数的中序排列
        }

        root -> left = reConstructBinaryTree(preLeftTree, inLeftTree);
        root -> right = reConstructBinaryTree(preRightTree, inRightTree);
        return root;

    }
//递归前序遍历二叉树
void preOrderTraversal(TreeNode* root)
{
    if (root != nullptr)
    {
        cout << root -> val << endl;
        preOrderTraversal(root -> left);
        preOrderTraversal(root -> right);
    }
}
int main()
{
    vector<int> pre{1,2,4,7,3,5,6,8},vin{4,7,2,1,5,3,8,6};
    TreeNode* p = reConstructBinaryTree(pre, vin);
    preOrderTraversal(p);
    return 0;
}

结果如下：

看了一个别人的

/** 
 * Definition for binary tree 
 * struct TreeNode { 
 *     int val; 
 *     TreeNode *left; 
 *     TreeNode *right; 
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {} 
 * }; 
 */  
class Solution  
{  
    public:  
        struct TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> in)  
        {  
            int lenp = pre.size();  
            int leni = in.size();  
            if(lenp==0 || leni==0 || lenp!=leni)  
                return nullptr;
  
            TreeNode *root = new TreeNode(pre[0]);  
            int mid = find(in.begin(),in.end(),pre[0])-in.begin();  
  
            vector<int> left_pre(pre.begin()+1,pre.begin()+1+mid);  
            vector<int> left_in(in.begin(),in.begin()+mid);  
            vector<int> right_pre(pre.begin()+1+mid,pre.end());  
            vector<int> right_in(in.begin()+mid+1,in.end());  
  
            root->left = reConstructBinaryTree(left_pre,left_in);  
            root->right = reConstructBinaryTree(right_pre,right_in);  
  
            return root;  
        }  
};