二叉树题目汇总

Leecode.617. 合并二叉树

给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。
你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。

思路：前序遍历

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if(t1==NULL) return t2;
        if(t2==NULL) return t1;
        t1->val+=t2->val;
        t1->left=mergeTrees(t1->left,t2->left);
        t1->right=mergeTrees(t1->right,t2->right);
        return t1;
    }
};

Leecode.572. 另一个树的子树

思路：dfs

class Solution {
public:
    bool isSubtree(TreeNode* s, TreeNode* t) {
        if(dfs(s,t)) return true;
        return isSubtree(s->left,t)||isSubtree(s->right,t);
        
    }
    bool dfs(TreeNode*s,TreeNode*t){
        if(s==nullptr&&t==nullptr) return true;
        if(s==nullptr||t==nullptr) return false;
        if(s->val!=t->val) return false;
        return dfs(s->left,t->left)&&dfs(s->right,t->right);
    }
};

Leecode.124. 二叉树中的最大路径和

给定一个非空二叉树，返回其最大路径和。
本题中，路径被定义为一条从树中任意节点出发，达到任意节点的序列。该路径至少包含一个节点，且不一定经过根节点
示例：
输入: [1,2,3]
输出: 6

思路：自顶向下递归遍历，最大路径和的四种情况：

• left - root - right
• left - root
• root - right
• root
  需要注意的是，返回的时候应是当前节点往左子树或者右子树其中之一的一条路径 ，并且用一个全局变量记录最大路径和。

class Solution {
public:
    int maxsum;
    int maxPathSum(TreeNode* root) {
        if(root==NULL) return 0;
        maxsum=root->val;
        dfs(root);
        return maxsum;                        
    }
    int dfs(TreeNode* root){
        if(root==NULL) return 0;
        int leftmax=max(0,dfs(root->left));
        int rightmax=max(0,dfs(root->right));
        maxsum=max(root->val+leftmax+rightmax,maxsum);
        return max(root->val+leftmax,root->val+rightmax);
    }
};

Leecode.199. 二叉树中的右视图

给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
输入: [1,2,3,null,5,null,4]
输出: [1, 3, 4]

思路：看到的应该是每层最右边的节点，故采用层次遍历

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int>res;
        if(root==NULL) return res;
        queue<TreeNode*>q;
        q.push(root);
        while(!q.empty()){
            int size=q.size();
            res.push_back(q.front()->val);
            while(size--){
                TreeNode*tmp=q.front();
                q.pop();
                if(tmp->right) q.push(tmp->right);
                if(tmp->left) q.push(tmp->left);
            }
        }
        return res;
    }
};

Leecode.98. 验证二叉搜索树

思路：递归，注意边界条件

class Solution {
public:
    bool isValidBST(TreeNode* root) {
        return dfs(root, LONG_MIN, LONG_MAX);
    }
    bool dfs(TreeNode*root,long long min,long long max){
        if(root==NULL) return true;
        if(root->val<=min||root->val>=max) return false;
        return dfs(root->left,min,root->val)&&dfs(root->right,root->val,max);
    }
};