LeetCode--二叉树系列（二）-优快云博客

本文深入探讨了二叉树的多种算法实现，包括路径总和、左叶子之和、对称性判断、最小深度和平衡性的检测。通过递归与深度优先搜索策略，解决了二叉树的关键问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

112.路径总和

解法：如果根节点值==target停止搜索。每次回朔采用sum-root->val

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool hasPathSum(TreeNode* root, int sum) {
        if(root==NULL) return false;
        if(root->val==sum&&root->left==NULL&&root->right==NULL) return true;
        return hasPathSum(root->left,sum-root->val)||hasPathSum(root->right,sum-root->val);
    }
};

404.左叶子之和

解法：递归因子就是当左子树的左右子树为空的时候就加上这个值。依次递归root->left root->right;

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int sumOfLeftLeaves(TreeNode* root) {
        int res = 0;
        if(root==NULL) return res;
        if(root->left!=NULL)
        {
            if(root->left->left==NULL&&root->left->right==NULL)
                res+=root->left->val;
        }
        res+=sumOfLeftLeaves(root->left);
        res+=sumOfLeftLeaves(root->right);
        return res;
    }
};

101.对称二叉树

解法：为false的三个条件：root==NULL 或者某一子树为空或者某左子树的值不等于右子树的值。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(root==NULL) return true;
        return rec(root->left,root->right);
    }
    bool rec(TreeNode* left,TreeNode* right)
    {
        if(left==NULL&&right==NULL) return true;
        if(left==NULL||right==NULL) return false;
        if(left->val!=right->val)
            return false;
        return rec(left->left,right->right)&&rec(right->left,left->right);
    }
};

111.二叉树的最小深度

解法1：暴力，求出每棵子树的长度，再进行比较。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    void getDepth(TreeNode* root, int high,vector<int>& height)
    {
        if(root->right) getDepth(root->right,high+1,height);
        if(root->left) getDepth(root->left,high+1,height);
        if(root->right==NULL&&root->left==NULL) height.push_back(high);
    }
    int minDepth(TreeNode* root) {
        if(root==NULL) return 0;
        vector<int> height;
        getDepth(root,1,height);
        int min = height[0];
        for(int i=1;i<height.size();i++)
            if(height[i]<min) min = height[i];
        return min;
    }
};

解法二：进行递归，递归因子就是每次在同一层取最小的那个++。如果左右子树都为空则深度为1.

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int minDepth(TreeNode* root) {
        if(root==NULL) return 0;
        if(root->left==NULL&&!root->right) return 1;
        int left,right;
        left = 200000;
        right = 200000;
        if(root->left) left = minDepth(root->left);
        if(root->right) right = minDepth(root->right);
        return min(left,right)+1;
    }
};

110.平衡二叉树

解法：平衡二叉树，左右子树的深度<=1。遍历每个节点，求其大深深度，然后判断。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int getDepth(TreeNode* root)
    {
        if(root==NULL) return 0;
        int left = getDepth(root->left);
        int right = getDepth(root->right);
        return max(left+1,right+1);
    }
    bool isBalanced(TreeNode* root) {
        if(root==NULL) return true;
        if(abs(getDepth(root->left)-getDepth(root->right))>1)
            return false;
        return (isBalanced(root->left)&&isBalanced(root->right));
    }
};