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

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

---

226.翻转二叉树

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

解题思路

这题和上一题层序遍历靠在一起，可以直接用层序遍历的方式解决，一层一层遍历，将每层的左右孩子翻转一下即可。

代码实现

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != nullptr)
            que.push(root);
        while (!que.empty()) {
            int size = que.size();
            while (size--) {
                TreeNode* node = que.front();
                que.pop();
                swap(node->left, node->right);
                if (node->left)
                    que.push(node->left);
                if (node->right)
                    que.push(node->right);
            }
        }
        return root;
    }
};

题目总结

本题使用前序遍历和后序遍历也都可以，但中序遍历不方便，中序遍历会将某些节点的左右孩子反转两次。

101.对称二叉树

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

解题思路

本题我选择使用递归法来解决，通过队列比较根节点的左右子树是否相互反转。

首先判断根节点左子树和右子树的内侧和外侧是否相等，使用两个指针指向根节点的左子树和右子树，然后将队列元素弹出并比较是否相等，若相等，继续将两个元素的左右孩子添加到队列中，弹出元素比较是否相同，如果最后队列为空没有找到两个不相同的元素，那么这棵二叉树就是对称二叉树。

代码实现

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if (root == nullptr)
            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;
    }
};

题目总结

本题也可以使用递归来解决，遍历顺序只能是后序遍历，因为要遍历两棵树，且要比较内外侧节点是否相等，一棵树的遍历顺序是左->右->中，另一棵是右->左->中。

104.二叉树的最大深度

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

解题思路

根节点的高度就是二叉树的最大深度，所以本题自然能想到使用层序遍历，层数就是二叉树的深度。

代码实现

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == nullptr)
            return 0;
        queue<TreeNode*> que;
        que.push(root);
        int depth = 0;
        while (!que.empty()) {
            int size = que.size();
            depth++;
            while (size--) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left)
                    que.push(node->left);
                if (node->right)
                    que.push(node->right);
            }
        }
        return depth;
    }
};

题目总结

本题递归法是要通过递归函数的返回值计算树的高度，使用后序遍历。

111.二叉树的最小深度

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

解题思路

最小深度是从根节点到最近叶子节点的最短路径上的节点数量，左右孩子为空的节点才是叶子节点。本题使用层序遍历来解决。

代码实现

暴力解法

class Solution {
public:
    int minDepth(TreeNode* root) {
        if (root == nullptr)
            return 0;
        queue<TreeNode*> que;
        que.push(root);
        int depth = 0;
        while (!que.empty()) {
            int size = que.size();
            depth++;
            while (size--) {
                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;
    }
};

题目总结

本题需要注意的是和上一题的区别，最小深度和最大深度的定义。