代码随想录训练营第十五天 | 二叉树的层次遍历＋翻转和对称二叉树

1.二叉树的层次遍历

也就是广度优先搜索，用队列去实现。

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<vector<int>> result;
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        return result;
    }
};

题107 自底而上的层次遍历

将自顶而下的层次遍历的结果reverse一下即可

题199 二叉树的右视图

将队列的最后一个元素放到result中，且注意两个if不要调换顺序，必须先left，再right。

题637 二叉树的层平均值

注意返回的数据类型是double。那么sum也为double

题429 N叉树的层序遍历

注意children中有多个节点，用下标children[i]区分

题515 在每个树行中找最大值

注意有时候并不需要定义vec保存每层的值

题111 二叉树的最小深度

当得到的值已经是结果的时候，可以用return直接返回结果。

2.翻转二叉树 题226

https://programmercarl.com/0226.%E7%BF%BB%E8%BD%AC%E4%BA%8C%E5%8F%89%E6%A0%91.html#%E9%80%92%E5%BD%92%E6%B3%95

用前序和后序遍历比较好，若是中序遍历，就会出现换了左子树，再回到中间交换左右子树，最后交换右子树，但前面的左已经换到了右，会重复交换。

深度优先搜索用递归去写。

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;
    }
};

也可用广度优先，用到队列。

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

3.对称二叉树 题101

https://programmercarl.com/0101.%E5%AF%B9%E7%A7%B0%E4%BA%8C%E5%8F%89%E6%A0%91.html

思路：比较外侧的两个结点值是否相等，内侧两个节点是否相等。用深度遍历的后序遍历法（正是因为要遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中）。

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 isSame = outside && inside;                    // 左子树：中、 右子树：中 （逻辑处理）
        return isSame;

    }
    bool isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        return compare(root->left, root->right);
    }
};