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

题目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);
    }
};

最后

判断是不是对称二叉树，这个比较绕，把一个树的左子树和右子树进行递归比较，先比较当前节点内容是否一直，一直在继续从上往下比较，在比较节点是否对称

二叉树的最小深度，注意二叉树最小深度的定义，比二叉树的最大深度加了两个判断条件

翻转二叉树，就是先翻转再递归

摆烂了一周，要继续练算法了，加油