二叉树：重建二叉树的统一写法（前序和中序重建，后序和中序重建）

这篇博客介绍了如何通过前序和中序，以及后序和中序遍历结果来重建二叉树。重点讲解了在使用中序和后序遍历重建二叉树时，需要调整左右子树构建顺序的原因，并提供了具体的构建过程。

重建二叉树（前序中序，后序中序）

根据前序和中序构建二叉树：

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int index=0;
    TreeNode* rebuild(vector<int> pre,vector<int> vin, int left, int right)
    {
        if(left==right || pre.size()==index)
        {
            return nullptr;
        }
        TreeNode *head=NULL;
        for(int i=left;i<right; i++)
        {
            if(pre[index]==vin[i])//查找分界点
            {
                
                head=new TreeNode(pre[index]);
                index++;
                head->left=rebuild(pre, vin,  left, i);
                head->right=rebuild(pre,  vin, i+1, right);
                break;
            }
        }
        return head;
        
    }
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        int left=0;
        int right=vin.size();
        TreeNode* head=rebuild(pre,vin,left,right);
        return head;
    }
};

新更新：
中序后序重建二叉树，和前序中序一样，不过调换了左右子树的构建顺序：

	 head->right = rebuild(vin, pos, i+1, right);
     head->left = rebuild(vin, pos, left, i);

因为index–后是右子树的根节点，所以先构建右子树。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int index = 0;
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        index = postorder.size() - 1;
        int left = 0;
        int right = inorder.size();
        TreeNode* head = rebuild(inorder, postorder, left, right);
        return head;
    }

    TreeNode* rebuild(vector<int> vin,vector<int> pos, int left, int right)
    {       
        if(left == right)
        {
            return nullptr;
        }
        TreeNode* head = NULL;
        for(int i = left; i < right; i++)
        {
            if(vin[i] == pos[index])
            {
                index--;
                head = new TreeNode(vin[i]);
                head->right = rebuild(vin, pos, i+1, right);
                head->left = rebuild(vin, pos, left, i);
                break;
            }
        }
        return head;
    }
};

↓下面的就不同看了↓我只是舍不得删…

根据中序和后序构建二叉树（注：pre暂为后序遍历）：
后序pre：[3,4,2,6,7,5,1]
中序vin：[3,2,4,1,6,5,7]
在这里插入图片描述

/**
 * 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* rebuild(vector<int> pre,vector<int> vin, int prel, int prer,int vinl,int vinr)
    {
        if(left==right)
        {
            return nullptr;
        }
        TreeNode *head=NULL;
        for(int i=vinl;i<=vinr; i++)
        {
            if(pre[prer]==vin[i])//查找中序遍历vin分界点i ，左边左子树，右边右子树
            {
                
                head=new TreeNode(pre[prer]);//构建根节点
                
                head->left=rebuild(pre, vin, prel,i-vinl-1+prel,vinl,i-1);//pre【prel，i-vinl-1+prel】和vin【vinl，i-1】构建左子树
                head->right=rebuild(pre,  vin, prel+i-vinl, prer-1,i+1,vinr);//pre【prel+i-vinl， prer-1l】和vin【i+1，vinr】构建左子树
                break;
            }
        }
        return head;
        
    }
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        TreeNode* head=rebuild(pre,vin,0,pre.size()-1,0,vin.size()-1);
        return head;
    }
};