Day10:翻转二叉树226 对称二叉树101 二叉树的最大深度104 二叉树的最小深度111

vpurple__

于 2024-07-14 15:56:20 发布

阅读量85

点赞数 3

分类专栏：题目分享：一些容易遗忘的小点文章标签：算法数据结构

本文链接：https://blog.csdn.net/vpurple_/article/details/140417965

版权

题目分享：一些容易遗忘的小点专栏收录该内容

23 篇文章 2 订阅

订阅专栏

题目226. 翻转二叉树 - 力扣（LeetCode）

/**
 * 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:
    void swapTree(TreeNode* root)
    {
        if(root==nullptr)
        {
            return ;
        }
        swap(root->right,root->left);
        swapTree(root->right);
        swapTree(root->left);
        return;
    }
    TreeNode* invertTree(TreeNode* root) {

        swapTree(root);
        return root;
    }
};

题目101. 对称二叉树 - 力扣（LeetCode）

/**
 * 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:
    bool compareTree(TreeNode* le,TreeNode* ri)
    {
        
        if(le==nullptr&&ri==nullptr)
        {
            return true;;
        }
        if(le==nullptr&&ri!=nullptr)
        {
            return false;
        }
        if(le!=nullptr&&ri==nullptr)
        {
            return false;
        }
          if(le->val!=ri->val)
        {
            return false;
        }
        bool bleft=compareTree(le->left,ri->right);
        bool bright=compareTree(le->right,ri->left);
        bool ball=bleft&&bright;
         
        return ball;
    }
    bool isSymmetric(TreeNode* root) {
        return compareTree(root->left,root->right);
    }
};

题目104. 二叉树的最大深度 - 力扣（LeetCode）

/**
 * 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 depthTree(TreeNode*root)
    {
        if(root==nullptr)
        {
            return 0;
        }
        int left=depthTree(root->left);
        int right=depthTree(root->right);
        return left>right?left+1:right+1;
    }
    int maxDepth(TreeNode* root) {
        return depthTree(root);
    }
};

题目111. 二叉树的最小深度 - 力扣（LeetCode）

/**
 * 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 depthTree(TreeNode* root) {
        if (root == nullptr) {
            return 0;
        }
        
        int left = depthTree(root->left);
        int right = depthTree(root->right);
        if((left==0&&right!=0))
        {
            return right+1;
        }
        if((left!=0&&right==0))
        {
            return left+1;
        }
       return left<right?left+1:right+1;
        
    }
    int minDepth(TreeNode* root) {
        return depthTree(root);
    }
};