算法训练-Day12 | 226.翻转二叉树 101. 对称二叉树 104.二叉树的最大深度 111.二叉树的最小深度 222.完全二叉树的节点个数

 226.翻转二叉树

/**
 * 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:
    // 确定递归函数的参数和返回值
    TreeNode* invertTree(TreeNode* root) {
        // 确定终止条件
        if(root == nullptr)   
            return nullptr;
        // 可以选择前序遍历或者后序遍历，不能选择中序遍历，因为中序遍历会把某些节点的左右孩子翻转两次
        // 确定单层递归的逻辑
        swap(root->left,root->right);
        invertTree(root->left);
        invertTree(root->right);
        return root;
    }
};

101. 对称二叉树

/**
 * 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 {
private:
    bool recur(TreeNode* L,TreeNode* R){
        //首先排除节点不相等的情况
        // 节点的值不相等或者没有都越过叶子节点，则说明该二叉树是不对称的
        if((L == nullptr&& R != nullptr))
            return false;
        else if(L != nullptr && R == nullptr)
            return false;
        else if(L == nullptr && R == nullptr)  // 如果对称，到最后肯定都是null，也就是都越过叶子节点
            return true;
        else if(L->val != R->val)   // 要先排除完空节点再排除数值不同的情况，不然判断条件不完整会报错
            return false;

        bool outside = recur(L->left,R->right);     // 外侧,左子树：左  右子树：右
        bool inside = recur(L->right,R->left);      // 内侧,左子树：右   右子树：左
        bool isSame = outside && inside;    // 外侧和内侧都为 true ，才说明是对称二叉树
        return isSame;
    }

public:
    bool isSymmetric(TreeNode* root) {
        if(root == nullptr)
            return true;
        
        return recur(root->left,root->right);
    }
};

104.二叉树的最大深度

注意二叉树节点深度和二叉树接节点高度概念的差异

树的高度就是最大深度，所以求树的最大深度可以通过求根节点的高度来进行求解

/**
 * 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 getDepth(TreeNode* root){
        // 终止条件:遇到空节点，说明高度为0
        if(root == nullptr)
            return 0;
        // 单层逻辑：先求左子树的深度，再求右子树的深度，因为还有根节点，所以在取左右子树深度的较大值之后还要 +1 ，最终得到的值就是该树的最大深度了
        int leftDepth = getDepth(root->left);
        int rightDepth = getDepth(root->right);
        int depth = 1 + max(leftDepth,rightDepth);
        return depth;
    }
    int maxDepth(TreeNode* root) {
        return getDepth(root);
    }
};

111.二叉树的最小深度

最小深度是从根节点到最近叶子节点的最短路径上节点数量。

叶子节点：左右孩子都为空节点的节点才是叶子节点。

注意图中的特殊情况：没有左孩子的节点并不是最小深度。

所以如果左子树为空，右子树不为空，则最小深度是 1+右子树的深度；如果右子树为空，左子树不为空，则最小深度为 1+左子树的深度；如果左右子树都不为空，返回 1+左右子树深度最小值

/**
 * 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 getDepth(TreeNode* root){
        // 终止条件：当前节点为空节点，返回 0
        if(root == nullptr)
            return 0;
        
        // 单层逻辑
        int leftDepth = getDepth(root->left);
        int rightDepth = getDepth(root->right);
        // 如果左子树为空，右子树不为空，则最小深度是 1+右子树的深度
        if(root->left == nullptr && root->right != nullptr)
            return 1+rightDepth;
        // 如果左子树不为空，右子树为空，则最小深度为 1+左子树的深度
        else if(root->left != nullptr && root->right == nullptr)
            return 1+leftDepth;
        int depth = 1 + min(leftDepth,rightDepth);      // 左右子树都不为空，才返回 1+左右子树深度最小值
        return depth;
    }

    int minDepth(TreeNode* root) {
        return getDepth(root);
    }
};