第十四天 第六章 二叉树 part02 226.翻转二叉树 101. 对称二叉树 104.二叉树的最大深度 111.二叉树的最小深度

226.翻转二叉树

这题就是单纯交换两个节点，可以直接写在原函数里面，调用原函数递归就行。交换可以使用swap()。

class Solution {
public:
     void traverse(TreeNode *cur){
            if(cur==nullptr)  return ;
            TreeNode * temp=cur->left;
            cur->left=cur->right;
            cur->right=temp;
            traverse(cur->left);
            traverse(cur->right);
        }

    TreeNode* invertTree(TreeNode* root) {
            traverse(root);
            return root;
    }
};

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == NULL) return root;
        swap(root->left, root->right);  // 中
        invertTree(root->left);         // 左
        invertTree(root->right);        // 右
        return root;
    }
};

也让可以使用后序

101. 对称二叉树

遍历左右节点，先排除左右分别为空以及不相等的情况，后面就可以进行递归了，内侧与内侧比较，外侧与外侧比较。

class Solution {
public:
    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;
    bool bo1=compare(left->left,right->right);
    bool bo2=compare(left->right,right->left);
    return bo1&&bo2;
    }
    bool isSymmetric(TreeNode* root) {
        if(root==nullptr) return true;
        return compare(root->left,root->right);
    }
};

104.二叉树的最大深度

这题使用后序遍历，使用求高度的方法求深度。 使用层序遍历更容易理解。 使用前序才是真正深度的求解方法(有点麻烦，不容易理解)。

class Solution {
public:
    int depth(TreeNode* root){
        if(root==nullptr) return 0;
        int left=depth(root->left);
        int right=depth(root->right);
        int res=1+max(left,right);
        return res;
    }
    int maxDepth(TreeNode* root) {
        return depth(root);
    }
};

111.二叉树的最小深度

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。 叶子节点表示左右节点都不存在。所以需要判断左右节点是否都为空。

class Solution {
public:
    int mindept(TreeNode* root){
       if(root==nullptr) return 0; 
       int left=mindept(root->left);
       int right=mindept(root->right);
       if(root->left!=nullptr&&root->right==nullptr){
            return left+1;
       }
         if(root->left==nullptr&&root->right!=nullptr){
         return right+1;
       }
       return 1+min(left,right);
    }
    int minDepth(TreeNode* root) {
        return mindept(root);
    }
};

上述都是使用递归的方法，后面要学习迭代法。  有些题前序后序都可以做，也需要后面去学会。