代码随想录算法训练营第十五天

最新推荐文章于 2025-12-19 15:31:04 发布

原创最新推荐文章于 2025-12-19 15:31:04 发布 · 101 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #leetcode #c++

代码训练营专栏收录该内容

26 篇文章

订阅专栏

本文介绍了二叉树的层序遍历、翻转二叉树的递归与迭代方法，以及如何判断对称二叉树。层序遍历利用队列实现，翻转通过递归或遍历交换节点的左右子树。对称性检查通过递归比较对应节点的值和结构。

代码随想录算法训练营第十五天

一、二叉树的层序遍历

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

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;  // 定义一个容器储存结果
        queue<TreeNode*> que;  // 定义队列遍历二叉树
        if(root != NULL)    que.push(root);  
        while(!que.empty()){
            int size = que.size();  // 记录每一层的节点树
            vector<int> vec; // 定义一个容器临时储存每一层节点的值
            while(size--){
                // 遍历每一层的节点，并添加节点的左右孩子
                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;

    }
};

二、226.翻转二叉树

递归法
1. 确定递归函数的参数和返回值：参数为要传入节点的指针。
2. **确定终止条件：**节点为空时返回。
3. **确定单层递归的逻辑：**因为是先前序遍历，所以先进行交换左右孩子节点，然后反转左子树，反转右子树。

class Solution {
public:
    void reverseTree(TreeNode* cur){
        if(cur == NULL) return;
        swap(cur->left,cur->right);
        reverseTree(cur->left);
        reverseTree(cur->right);
    }

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

迭代法

深度优先遍历

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();
            if(node != NULL){
                st.pop();
                // 前序，入栈顺序为右左中
                if(node->right != NULL) st.push(node->right);
                if(node->left != NULL) st.push(node->left);
                st.push(node);
                st.push(NULL);
                
                // 后序， 入栈顺序为中右左
                /*
                st.push(node);
                st.push(NULL);
                if(node->right != NULL) st.push(node->right);
                if(node->left != NULL) st.push(node->left);
                */
                
            }
            else{
                st.pop();
                node = st.top();
                swap(node->left, node->right);
                st.pop();
            }
        }
        return root;
    }
};

广度优先遍历

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

三、101.对称二叉树

按照对称的顺序遍历整个二叉树，对比外侧的节点是否对称，对比内侧的节点是否对称。

class Solution {
public:
    bool is_symmetric(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 = is_symmetric(left->left, right->right);
        bool inside = is_symmetric(left->right, right->left);
        bool result = outside & inside;
        return result;
    }
    bool isSymmetric(TreeNode* root) {
        bool result = is_symmetric(root->left, root->right);
        return result;

    }
};