【LeetCode】11.二叉树系列——构造与修改

总目录：

LeetCode系列导航目录

 

0.理论基础

0.1.根据前/中/后序遍历结果中的2个来构建树

前提：

前序和后序不能用来构建树，因为不能切割左右子树的范围。

步骤：

（1）确认根节点；

（2）切割数组；

（3）递归构建左右子树；

构造二叉树有三个注意的点：

（1）分割时候，坚持区间不变量原则，左闭右开，或者左闭右闭；

（2）分割的时候，注意后序 或者 前序已经有一个节点作为中间节点了，不能继续使用了；

（3）如何使用切割后的后序数组来切合中序数组？利用中序数组大小一定是和后序数组的大小相同这一特点来进行切割。

0.2.要点

222

0.3.代码实例

333

 

1.从中序和后序遍历序列构建二叉树

1.1.问题描述

给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树 。

 

 

链接：https://leetcode.cn/problems/construct-binary-tree-from-inorder-and-postorder-traversal

1.2.要点

根节点是后序遍历的最后一个

1.3.代码实例

递归

class Solution {
public:
    TreeNode* build(vector<int>& inorder,int start1,int end1,
    vector<int>& postorder,int start2,int end2){
        if(start1>end1||start2>end2){
            return NULL;
        }

        //后序遍历最后一个节点是根节点
        TreeNode* root=new TreeNode(postorder[end2]);

        //找到根节点在中序遍历中的序号
        int rootInOrder=start1;
        while(inorder[rootInOrder]!=postorder[end2]){
            rootInOrder++;
        }
        
        //切割左树
        int newStart1=start1;
        int newEnd1=rootInOrder-1;
        int newStart2=start2;
        int newEnd2=start2+(rootInOrder-1-start1);
        root->left=build(inorder,newStart1,newEnd1,postorder,newStart2,newEnd2);

        //切割右树
        newStart1=rootInOrder+1;
        newEnd1=end1;
        newStart2=start2+(rootInOrder-1-start1)+1;
        newEnd2=end2-1;   
        root->right=build(inorder,newStart1,newEnd1,postorder,newStart2,newEnd2);
        
        return root;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        int dataLen1=inorder.size();
        int dataLen2=postorder.size();
        if(inorder.size()<=0||postorder.size()<=0){
            return NULL;
        }

        return build(inorder,0,postorder.size()-1,postorder,0,postorder.size()-1);   
    }
};

 

2.从前序和中序遍历序列构建二叉树

2.1.问题描述

给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

链接：https://leetcode.cn/problems/construct-binary-tree-from-preorder-and-inorder-traversal

2.2.要点

前序遍历的第一个节点是根节点

2.3.代码实例

递归

class Solution {
public:
    TreeNode* build(vector<int>& preorder,int start1,int end1,
    vector<int>& inorder,int start2,int end2){
        if(start1>end1||start2>end2){
            return NULL;
        }

        //前序遍历第一个节点是根节点
        TreeNode* root=new TreeNode(preorder[start1]);

        //找到根节点在中序遍历中的序号
        int rootInOrder=start2;
        while(inorder[rootInOrder]!=preorder[start1]){
            rootInOrder++;
        }
        
        //切割左树
        int newStart2=start2;
        int newEnd2=rootInOrder-1;
        int newStart1=start1+1;
        int newEnd1=start1+1+(newEnd2-newStart2);
        root->left=build(preorder,newStart1,newEnd1,inorder,newStart2,newEnd2);

        //切割右树
        newStart2=rootInOrder+1;
        newEnd2=end2;   
        newStart1=newEnd1+1;
        newEnd1=end1;

        root->right=build(preorder,newStart1,newEnd1,inorder,newStart2,newEnd2);
        
        return root;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int dataLen1=preorder.size();
        int dataLen2=inorder.size();
        if(preorder.size()<=0||inorder.size()<=0){
            return NULL;
        }

        return build(preorder,0,preorder.size()-1,inorder,0,inorder.size()-1); 
    }
};

 

3.最大二叉树

3.1.问题描述

给定一个不重复的整数数组 nums 。 最大二叉树 可以用下面的算法从 nums 递归地构建:
（1）创建一个根节点，其值为 nums 中的最大值。
（2）递归地在最大值 左边 的 子数组前缀上 构建左子树。
（3）递归地在最大值 右边 的 子数组后缀上 构建右子树。
返回 nums 构建的 最大二叉树 。
链接：https://leetcode.cn/problems/maximum-binary-tree

3.2.要点

递归，进阶是降低搜索最大值的时间复杂度

3.3.代码实例

递归

class Solution {
public:
    TreeNode* build(vector<int>& nums,int start,int end){
        if(start>end){
            return NULL;
        }

        //寻找最大值
        int maxVal=INT_MIN;
        int maxId=-1;
        for(int i=start;i<=end;i++){
            if(nums[i]>maxVal){
                maxVal=nums[i];
                maxId=i;
            }
        }

        //构建根节点，及左右子树
        TreeNode* root=new TreeNode(maxVal);
        root->left=build(nums,start,maxId-1);
        root->right=build(nums,maxId+1,end);

        return root;
    }
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        int dataLen=nums.size();
        if(dataLen<=0){
            return NULL;
        }

        return build(nums,0,dataLen-1);
    }
};

 

4.合并二叉树

4.1.问题描述

给你两棵二叉树： root1 和 root2 。
想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。
返回合并后的二叉树。
注意: 合并过程必须从两个树的根节点开始。

 

 链接：https://leetcode.cn/problems/merge-two-binary-trees

4.2.要点

1递归

2迭代，递归的栈版本

3迭代，层序遍历

4.3.代码实例

递归

class Solution {
public:
    
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        TreeNode* newNode=NULL;
        if(root1==NULL&&root2==NULL){
            newNode= NULL;
        }
        else if(root1==NULL&&root2!=NULL){
            newNode=root2;
        }
        else if(root1!=NULL&&root2==NULL){
            newNode=root1;
        }
        else{
            newNode=root2;
            root2->val=root1->val+root2->val;
            root2->left=mergeTrees(root1->left,root2->left);
            root2->right=mergeTrees(root1->right,root2->right);
        }

        return newNode;
    }
};

迭代，递归的栈版本

class Solution {
public:    
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if(!root1)
            return root2;
        if(!root2)
            return root1;
        
        stack<pair<TreeNode*, TreeNode*>> stk;
        stk.push(pair<TreeNode*,TreeNode*>(root1,root2));

        while(stk.size()){
            auto p = stk.top();
            auto p1 = p.first, p2 = p.second;
            stk.pop();
            p1->val += p2->val;

            if(p1->left && p2->left){
                stk.push({p1->left, p2->left});
            }
            if(p1->right && p2->right){
                stk.push({p1->right,p2->right});
            }
            if(!p1->left && p2->left){
                p1->left = p2->left;
            }
            if(!p1->right && p2->right){
                p1->right = p2->right;
            }
        }
        return root1;
    }
};

迭代，层序遍历

class Solution {
    public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
    //如果 t1和t2中，只要有一个是null，函数就直接返回
        if(t1==null || t2==null) {
            return t1==null? t2 : t1;
        }
        java.util.LinkedList<TreeNode> queue = new java.util.LinkedList<TreeNode>();
        queue.add(t1);
        queue.add(t2);
        while(queue.size()>0) {
            TreeNode r1 = queue.remove();
            TreeNode r2 = queue.remove();
            r1.val += r2.val;
            //如果r1和r2的左子树都不为空，就放到队列中
            //如果r1的左子树为空，就把r2的左子树挂到r1的左子树上
            if(r1.left!=null && r2.left!=null){
                queue.add(r1.left);
                queue.add(r2.left);
            }
            else if(r1.left==null) {
                r1.left = r2.left;
            }
            //对于右子树也是一样的
            if(r1.right!=null && r2.right!=null) {
                queue.add(r1.right);
                queue.add(r2.right);
            }
            else if(r1.right==null) {
                r1.right = r2.right;
            }
        }
        return t1;
    }
}

 

 

 

xxx.问题

xxx.1.问题描述

111

xxx.2.要点

222

xxx.3.代码实例

333