代码随想录算法训练营第十四天| 226.翻转二叉树 101. 对称二叉树 104.二叉树的最大深度 111.二叉树的最小深度-CSDN博客

本文链接：https://blog.csdn.net/y1158643600/article/details/141195667

一、LeetCode 226.翻转二叉树

文章讲解：代码随想录
视频讲解：听说一位巨佬面Google被拒了，因为没写出翻转二叉树 | LeetCode：226.翻转二叉树

思路：

题目要求，将一棵满二叉树进行镜像翻转，实际上就是更换每个结点的左右孩子；由于每个结点的操作过程基本重复，这中含有大量重复操作的过程我们可以采用递归或迭代来实现；由于迭代法实际上是用栈实现的递归，所以这里一刷只写出递归代码，后续再刷时进行方法的扩展。
在这里插入图片描述

笔者的递归函数主题操作是对当前结点的左右孩子进行交换，因此确定递归的终止条件为：当前结点的左右孩子都为空；对下一级的递归传参则分别为传入左右孩子结点的指针，由此可写出递归函数以及递归调用的代码如下：

C++代码

/**
 * 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 invert(TreeNode* node){
        if(node->left || node->right){
            TreeNode* tmp = node->left;
            node->left = node->right;
            node->right = tmp;
            if(node->left) invert(node->left);
            if(node->right) invert(node->right);
        }
    }
    TreeNode* invertTree(TreeNode* root) {
        if(root) invert(root);
        return root;
    }
};

二、LeetCode 101. 对称二叉树

题目链接：LeetCode 101. 对称二叉树

文章讲解：代码随想录
视频讲解：新学期要从学习二叉树开始！ | LeetCode：101. 对称二叉树

思路

判断一棵满二叉树是否对称，可以分别遍历左右子树中的对称位置，即：（左孩子的左子树，右孩子的右子树）与（左孩子的右子树，右孩子的左子树）；由于每个结点的判断过程也是重复操作，因此可以使用递归算法进行实现。

C++代码

/**
 * 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 traversal_comp(TreeNode* left, TreeNode* right) {
        if (left && right) { //左右对称位置都存在
            if (left->val == right->val) { //当前对称位置值相等
            	//对称位置判断
                return traversal_comp(left->left, right->right) &&
                       traversal_comp(left->right, right->left);
            }
        }
        if(!left && !right){ //当前对称位置为空
            return true;
        }
        return false;
    }
    bool isSymmetric(TreeNode* root) {
        return traversal_comp(root->left, root->right);
    }
};

二、LeetCode 104.二叉树的最大深度

题目链接：LeetCode 104.二叉树的最大深度

文章讲解：代码随想录
视频讲解：二叉树的高度和深度有啥区别？究竟用什么遍历顺序？很多录友搞不懂 | LeetCode：104.二叉树的最大深度

思路

使用递归的思想，在每个结点处求自己左右子树的最大深度+1，返回即可；终止条件为访问到空节点返回 $0$ 。

C++代码

/**
 * 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 depth_calc(TreeNode* node){
        if(!node){
            return 0;
        }
        return max(depth_calc(node->left), depth_calc(node->right))+1;
    }
    int maxDepth(TreeNode* root) {
        return depth_calc(root);
    }
};

二、LeetCode 111.二叉树的最小深度

题目链接：LeetCode 111.二叉树的最小深度

文章讲解：代码随想录
视频讲解：看起来好像做过，一写就错！ | LeetCode：111.二叉树的最小深度

思路

求最小深度，其实就是要遍历二叉树每一层结点，直到找出第一个叶子结点中止，当前的层数即为最小深度。

要注意叶子结点的判断条件，不能只找到一个1度结点就返回。

C++代码

/**
 * 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 minDepth(TreeNode* root) { //层次遍历
        queue<TreeNode*> que;
        int depth = 0; //depth记录当前层数
        if(root){
            que.push(root);
        }
        while(!que.empty()){
            int size = que.size();
            depth++;
            for(int i = 0; i < size; i++){
                TreeNode* node = que.front();
                que.pop();
                if(!node->left && !node->right){ //叶子结点
                    return depth;
                }
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return depth;
    }
};