代码随想录算法训练营第14天| 226.翻转二叉树、101. 对称二叉树、104.二叉树的最大深度、111.二叉树的最小深度

226.翻转二叉树、

题目链接：226.翻转二叉树

思路：写出中序遍历的序列之后，发现这棵树变化前后的遍历顺序是相反的。所以我们对于树只要交换他的左右孩子就好了，这里使用了前序遍历。需要注意的是如果有的地方是空节点的话需要先new一个节点出来。

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        //从最底层开始互换
        visit(root);
        return root;
    }
    void visit(TreeNode* root){
        //先序遍历
        if(root==nullptr) return;
        TreeNode* temp = new TreeNode;
        if(root->left==nullptr&&root->right==nullptr) return;
        temp=root->left;
        root->left=root->right;
        root->right=temp;
        visit(root->left);
        visit(root->right);
    }
};

101. 对称二叉树

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

思路：看左右子树翻转过来是否相等。所以说要对两个树进行遍历，从外到内看他们的值是否相等或者是否存在。当两个树分别的左右孩子都满足条件后才可以看父节点是否满足条件，否则没有意义，因此这里也要采用后序遍历，最后访问根节点。由外到内，再到父节点。

递归三部曲：1.先确定参数和返回值  2.确定终止条件  3.确定单层递归逻辑

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        return compare(root->left,root->right);
    }
    //后序遍历
    //想要知道二叉树是否对称
    //首先要左右孩子对称才能去看父节点是否对称 否则没有意义
    bool compare(TreeNode* left,TreeNode* right){
        if(left!=nullptr&&right==nullptr) return false;//左不为空
        else if(left==nullptr&&right!=nullptr) return false;//右不为空
        else if(left==nullptr&&right==nullptr) return true;//左右都为空
        else if(left->val!=right->val) return false;//左右值不相等
        else{          
            return compare(left->left,right->right)&&compare(left->right,right->left);//先比外面 //再比里面
        }
    }
};

104.二叉树的最大深度

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

思想：先序和递归。首先把最大值设置为0，之后开始遍历二叉树，每到一层，深度加1，遇到有节点的左右孩子都为空则比较当前深度与最大深度，如果大于则替换。

class Solution {
public:
    int maxDepth(TreeNode* root) {
        //记录当前最大深度 有更大的就替换
        int maxres = 0;
        visit(0,maxres,root);
        return  maxres;
    }
    void visit(int max, int& maxres, TreeNode* root){
        if(root!=nullptr){
            //先序
            max++;
            if(max>maxres) maxres=max;
            visit(max,maxres,root->left);
            visit(max,maxres,root->right);
        }
    }
};

111.二叉树的最小深度

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

思想：用了前序遍历和递归。首先把最小值设置为INT_MAX，之后开始遍历二叉树，每到一层，深度加1，遇到有节点的左右孩子都为空则比较当前深度与最小深度，如果小于则替换。

class Solution {
public:
    int minDepth(TreeNode* root) {
        if(root==nullptr) return 0;
        int minnum = INT_MAX;
        visit(0, minnum, root);
        return minnum;
    }
    void visit(int depth, int& minnum, TreeNode* root) {
        // 先序
        if (root != nullptr) {
            depth++;
            if (root->left == nullptr && root->right == nullptr)
                minnum = min(minnum, depth);
            else {
                visit(depth, minnum, root->left);
                visit(depth, minnum, root->right);
            }
        }
    }
};