226 反转二叉树

力扣题目链接

题目描述：

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

示例 1：

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

代码：

class Solution {
public:

    TreeNode* invertTree(TreeNode* root) {
     if(root!=NULL)return root;
     swap(root->right,root->left);
     //递归遍历，深入到下一深度
     invertTree(root->left);
     invertTree(root->right);
     return root;
    }
};

递归在遍历二叉树时，每次往下递推就是到下一深度，直到最底层

每一次归位就是循环结束，归出此层（回到上一层）

101对称二叉树 

力扣题目链接

给你一个二叉树的根节点 root ， 检查它是否轴对称。

示例 1：

输入：root = [1,2,2,3,4,4,3]
输出：true

示例 2：

输入：root = [1,2,2,null,3,null,3]
输出：false

代码：

/**
 * 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 compare(TreeNode*left,TreeNode*right){
        //判断的呢返回语句在这里
        if(left!=NULL&&right==NULL)return false;
        else if(left==NULL&&right!=NULL)return false;
        else if(left==NULL&&right==NULL)return true;
        else if(left->val!=right->val)return false;
     
        //边界判断（递归）
        bool outside=compare(left->left,right->right);
        //内层判断（递归）
        bool inside=compare(left->right,right->left);
        //怎样都判断的是对称的
        //边界跟内层的与运算为真才符合要求
        bool result=outside && inside;
        return result;
    }
    bool isSymmetric(TreeNode* root) {
      //直接调用
      if(root==NULL)return true;   
      return compare(root->left,root->right);
    }
};

104二叉树最大深度  

力扣题目链接

题目描述：如题

代码：（层序遍历的模板，加一个depth的计数器）

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == NULL) return 0;
        int depth = 0;
        queue<TreeNode*> que;
        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) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return depth;
    }
};

每退出一次for循环就是往下深入一层，depth++

111二叉树最小深度

代码：

class Solution {
public:
    int minDepth(TreeNode* root) {
        if (root == NULL) return 0;
        int depth = 0;
        queue<TreeNode*> que;
        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) que.push(node->left);
                if (node->right) que.push(node->right);
                if (!node->left && !node->right) { // 当左右孩子都为空的时候，说明是最低点的一层了，退出
                    return depth;
                }
            }
        }
        return depth;
    }
};

遍历某一层的时候，一旦发现左右子树都为空，意思就是该节点是叶节点，就直接返回