训练营第十五天 | ● 层序遍历 10 ● 226.翻转二叉树 ● 101.对称二叉树 2-CSDN博客

本文链接：https://blog.csdn.net/weixin_44824156/article/details/139106751

层序遍历 10

题目：

给你一个二叉树，请你返回其按层序遍历得到的节点值。（即逐层地，从左到右访问所有节点）。

思路：

队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        // 定义一个队列用于广度优先搜索（BFS）
        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;
    }
};

class Solution {
public:
    // 辅助函数，用于递归遍历二叉树，并按层次顺序将节点值存入结果向量
    void order(TreeNode* cur, vector<vector<int>>& result, int depth) {
        // 如果当前节点为空，则返回
        if (cur == nullptr) return;

        // 如果当前深度等于结果向量的大小，表示这一层还没有被记录，则创建一个新的向量表示这一层
        if (result.size() == depth) 
            result.push_back(vector<int>());
        
        // 将当前节点的值添加到对应深度的向量中
        result[depth].push_back(cur->val);

        // 递归遍历左子节点，深度加1
        order(cur->left, result, depth + 1);

        // 递归遍历右子节点，深度加1
        order(cur->right, result, depth + 1);
    }

    // 主函数，用于返回二叉树的层次遍历结果
    vector<vector<int>> levelOrder(TreeNode* root) {
        // 存储结果的向量，初始为空
        vector<vector<int>> result;
        
        // 初始深度为0
        int depth = 0;

        // 调用辅助函数进行递归遍历
        order(root, result, depth);

        return result;
    }
};

226.翻转二叉树

翻转它其实就把每一个节点的左右孩子交换一下。

递归法

以前序遍历为例，动画来看一下翻转的过程:

翻转二叉树

1.确定递归函数的参数和返回值

参数就是要传入节点的指针，通常此时定下来主要参数，如果在写递归的逻辑中发现还需要其他参数的时候，随时补充。返回值的话其实也不需要，但是题目中给出的要返回root节点的指针，可以直接使用题目定义好的函数，所以就函数的返回类型为TreeNode*。

2. 确定终止条件

3. 确定单层递归的逻辑

class Solution {
public:
    // 主函数，用于翻转二叉树
    TreeNode* invertTree(TreeNode* root) {
        // 如果根节点为空，直接返回空节点
        if (root == NULL) return root;

        // 创建一个栈用于存储节点
        stack<TreeNode*> st;
        // 将根节点压入栈中
        st.push(root);

        // 当栈不为空时，持续进行循环
        while (!st.empty()) {
            // 取出栈顶节点
            TreeNode* node = st.top();
            // 将栈顶节点弹出
            st.pop();

            // 翻转当前节点的左右子节点
            swap(node->left, node->right);

            // 如果右子节点不为空，将右子节点压入栈中
            if (node->right) st.push(node->right);

            // 如果左子节点不为空，将左子节点压入栈中
            if (node->left) st.push(node->left);
        }

        // 返回翻转后的根节点
        return root;
    }
};

101.对称二叉树 2

题目：

给定一个二叉树，检查它是否是镜像对称的。

101. 对称二叉树

确定递归函数的参数和返回值

因为要比较的是根节点的两个子树是否是相互翻转的，进而判断这个树是不是对称树，所以要比较的是两个树，参数自然也是左子树节点和右子树节点。

返回值自然是bool类型。

2. 确定终止条件

要比较两个节点数值相不相同，首先要把两个节点为空的情况弄清楚！

节点为空的情况有：

左节点为空，右节点不为空，不对称，return false
左不为空，右为空，不对称 return false
左右都为空，对称，返回true

此时已经排除掉了节点为空的情况，那么剩下的就是左右节点不为空：

左右都不为空，比较节点数值，不相同就return false

此时左右节点不为空，且数值也不相同的情况我们也处理了。

3. 确定单层递归的逻辑

此时才进入单层递归的逻辑，单层递归的逻辑就是处理左右节点都不为空，且数值相同的情况。

比较二叉树外侧是否对称：传入的是左节点的左孩子，右节点的右孩子。
比较内侧是否对称，传入左节点的右孩子，右节点的左孩子。
如果左右都对称就返回true ，有一侧不对称就返回false 。

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