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

1、翻转二叉树

题目链接/文章讲解/视频讲解：代码随想录

代码：递归 （前序）

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

 代码：迭代（前序）

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        stack<TreeNode*> st;
        if(root != NULL) st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top();
            st.pop();
            if(node == NULL) continue;
            swap(node->left,node->right);
            // 右
            st.push(node->right);
            // 左
            st.push(node->left);
        }
        return root;
    }
};

代码： 统一迭代（前序）

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        stack<TreeNode*> st;
        if(root != NULL) st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top();
            if(node != NULL){
                st.pop();
                // 中
                st.push(node);
                st.push(NULL);
                // 左
                if(node->left) st.push(node->left);
                // 右
                if(node->right) st.push(node->right);
            }else{
                st.pop();
                node = st.top();
                st.pop();
                swap(node->left,node->right);
            }
        }
        return root;
    }
};

note：这道题用中序会很麻烦，因为可以在翻转的过程中，导致一些翻转过的子树又被翻转回去了，而一些子树没有被翻转过。 

2、对称二叉树

题目链接/文章讲解/视频讲解：代码随想录

代码： 

class Solution {
public:
    bool traversal(TreeNode* left,TreeNode* right){
        if(left == NULL && right == NULL){
            return true;
        }else if(left == NULL && right != NULL){
            return false;
        }else if(left != NULL && right == NULL){
            return false;
        }else if(left->val != right->val){
            return false;
        }
        // 左
        bool outside = traversal(left->left,right->right);
        // 右
        bool inside = traversal(left->right,right->left);
        // 中
        return outside && inside;
    }
    bool isSymmetric(TreeNode* root) {
        if(root == NULL) return true;
        bool result = traversal(root->left,root->right);
        return result;
    }
};

代码：层序遍历 

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(root == NULL) return true;
        queue<TreeNode*> que;
        que.push(root->left);
        que.push(root->right);
        while(!que.empty()){
            TreeNode* leftNode = que.front();
            que.pop();
            TreeNode* rightNode = que.front();
            que.pop();
            if(!leftNode && !rightNode){
                continue;
            }
            if(!leftNode || !rightNode || leftNode->val != rightNode->val){
                return false;
            }
            que.push(leftNode->left);
            que.push(rightNode->right);
            que.push(leftNode->right);
            que.push(rightNode->left);
        }
        return true;
    }
};

 note：比较的是两个子树，因此递归的参数是两个参数。

只能采用后序遍历，因为我们需要左右孩子的信息返回来做判断。

相关题目练习

 100. 相同的树 - 力扣（LeetCode）

class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        // 递归出口
        if(p == NULL && q == NULL){
            return true;
        }else if(p != NULL && q == NULL){
            return false;
        }else if(p == NULL && q != NULL){
            return false;
        }else if(p->val != q->val){
            return false;
        }
        // 左
        bool left = isSameTree(p->left,q->left);
        // 右
        bool right = isSameTree(p->right,q->right);
        // 中
        return left && right;
    }
};

note：p->val == p->right 的情况不用直接返回true，只要排除了其它情况，就是这种情况。而且我们还需要结合左右子树的返回信息综合做判断。 

3、二叉树的最大深度

题目链接/文章讲解/视频讲解： 代码随想录

class Solution {
public:
    int traversal(TreeNode* node){
        if(node == NULL) return 0;
        // 左
        int left = traversal(node->left);
        // 右
        int right = traversal(node->right);
        // 中
        return max(left,right) + 1;
    }
    int maxDepth(TreeNode* root) {
        return traversal(root);
    }
};

 note：也是中序遍历 需要左右结点返回的信息来处理中间结点

4、二叉树的最小深度

题目链接/文章讲解/视频讲解：代码随想录

class Solution {
public:
    int traversal(TreeNode* node){
        if(node == NULL) return 0;
        int leftDepth = traversal(node->left);
        int rightDepth = traversal(node->right);
        if(node->left == NULL && node->right != NULL){
            return rightDepth + 1;
        }else if(node->left != NULL && node->right ==NULL){
            return leftDepth + 1;
        }
        return min(leftDepth,rightDepth) + 1;
    }
    int minDepth(TreeNode* root) {
        return traversal(root);
    }
};

 note:当一个结点的左右孩子只有一个为空时，不算是最小深度。