代码随想录算法训练营day15 | 层次遍历，226.翻转二叉树,101对称二叉树

于 2024-03-23 21:53:03 发布
阅读量882 收藏 19
点赞数 16
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46536635/article/details/136922371
版权
文章详细介绍了C++中二叉树的层序遍历、层次遍历II、右视图、层平均值以及N叉树的层序遍历等算法，并提供了相关LeetCode题目示例。还涉及到了翻转二叉树和对称二叉树的判断方法。
摘要由CSDN通过智能技术生成

层次遍历

文章链接：代码随想录 (programmercarl.com)

视频链接：讲透二叉树的层序遍历 | 广度优先搜索 | LeetCode：102.二叉树的层序遍历_哔哩哔哩_bilibili

​​​​

C++代码

相关题目 

  • 102.二叉树的层序遍历(opens new window)
  • class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        if(root!=nullptr)que.push(root);
        vector<vector<int>>result;
        while(!que.empty()){
            int size=que.size();
            vector<int> vec;
            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.二叉树的层次遍历II(opens new window)
  • class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>> result;
        if(root!=nullptr)que.push(root);
        while(!que.empty()){
            int size=que.size();
            vector<int>vec;

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

        }
        reverse(result.begin(),result.end());
        return result;
    }
};

  • 199.二叉树的右视图(opens new window)
  • class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        vector<int>res;
        if(root!=nullptr)que.push(root);
        while(!que.empty()){           
            int size=que.size();  
            TreeNode* node=que.back(); 
            res.push_back(node->val);      
            for(int i=0;i<size;i++){
                TreeNode* cur=que.front();
                que.pop();  
                if(cur->left)que.push(cur->left);
                if(cur->right)que.push(cur->right);
            }
            
            
        }
        return res;
    }

  • 637.二叉树的层平均值(opens new window)
  • class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> res;
        queue<TreeNode*>que;
        if(root!=nullptr)que.push(root);
        while(!que.empty()){
            int size=que.size();
            double count=0;
            for(int i=0;i<size;i++){
                TreeNode* node=que.front();
                que.pop();
                count +=node->val;
                if(node->left)que.push(node->left);
                if(node->right)que.push(node->right);

            }
            count /=size;
            res.push_back(count);
        }
        return res;
    }
};

  • 429.N叉树的层序遍历(opens new window)
  • 急需复习下基础知识
  • class Solution {
public:
// 没有nullptr孩子 所以不用判断 child 为nullptr的情况
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>> res;
        queue<Node*> que;
        if(root)que.push(root);
        while(!que.empty()){
            int size=que.size();
            vector<int> vec;
            for(int i=0;i<size;i++){
                Node* cur=que.front();
                que.pop();
                vec.push_back(cur->val);
                for(Node* childe : cur->children){
                    que.push(childe);
                }
            }
            res.push_back(vec);
        }
        return res;
    }
};

  • 515.在每个树行中找最大值(opens new window)
  • class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        vector<int> res;
        queue<TreeNode*> que;
        if(root)que.push(root);
        
        while(!que.empty()){
            int size=que.size();
            int count=INT_MIN;
            for(int i=0;i<size;i++){
                TreeNode* node=que.front();
                que.pop();
                count= count > node->val ? count : node->val;
                if(node->left)que.push(node->left);
                if(node->right)que.push(node->right);


            }
            res.push_back(count);

        }
        return res;
    }
};

  • 116.填充每个节点的下一个右侧节点指针(opens new window)
  • class Solution {
public:
    Node* connect(Node* root) {
        if(root==NULL)return root;
        queue<Node*>que;
        que.push(root);
        while(!que.empty()){
            int size=que.size();
            for(int i=0;i<size;i++){
                Node* cur=que.front();
                que.pop();
                if(i==size-1){
                    cur->next=NULL;
                }else{
                    cur->next=que.front();
                }
                if(cur->left)que.push(cur->left);
                if(cur->right)que.push(cur->right);
            }
        }
        return root;
    }
};

  • 117.填充每个节点的下一个右侧节点指针II(opens new window)
  • class Solution {
public:
    Node* connect(Node* root) {
        if(root==NULL)return root;
        queue<Node*>que;
        que.push(root);
        while(!que.empty()){
            int size=que.size();
            for(int i=0;i<size;i++){
                Node* cur=que.front();
                que.pop();
                if(i==size-1){
                    cur->next=NULL;
                }else{
                    cur->next=que.front();
                }
                if(cur->left)que.push(cur->left);
                if(cur->right)que.push(cur->right);
            }
        }
        return root;
    }
};

  • 104.二叉树的最大深度(opens new window)
  • class Solution {
public:
    int maxDepth(TreeNode* root) {
        int count=0;
        if(root==nullptr)return count;
        queue<TreeNode*> que;
        que.push(root);
        
        while(!que.empty()){
            count++;
            int size=que.size();
            for(int i=0;i<size;i++){
                TreeNode* node=que.front();
                que.pop();
                if(node->left)que.push(node->left);
                if(node->right)que.push(node->right);
            }

        }
        return count;

    }
};

  • 111.二叉树的最小深度
  • class Solution {
public:
    int minDepth(TreeNode* root) {
        int count=0;
        if(root==nullptr)return count;
        queue<TreeNode*>que;
        que.push(root);
        while(!que.empty()){
            count++;
            int size=que.size();
            for(int i=0;i<size;i++){
                TreeNode* node=que.front();
                que.pop(); 
                if(node->right==nullptr && node->left==nullptr)return count;
                if(node->left)que.push(node->left);
                if(node->right)que.push(node->right);
            } 
            
            
        }
        return count;
    }
};

226. 翻转二叉树

文章链接：代码随想录 (programmercarl.com)

视频链接：听说一位巨佬面Google被拒了，因为没写出翻转二叉树 | LeetCode：226.翻转二叉树_哔哩哔哩_bilibili

笔记 

  • 不太熟悉怎么写递归了，要有返回值，终止条件和逻辑

C++代码 

class Solution {
public:
    TreeNode* TreeInvert(TreeNode* root){
        if(root==nullptr)return root;
        swap(root->left,root->right);
        TreeInvert(root->left);
        TreeInvert(root->right);
        return root; 
    }
    TreeNode* invertTree(TreeNode* root) {
        TreeInvert(root);
        return root;
    }
};

文章链接：代码随想录 (programmercarl.com)

视频链接：新学期要从学习二叉树开始！ | LeetCode：101. 对称二叉树_哔哩哔哩_bilibili

笔记

  • 比较的不是左右子树，是里侧和外侧
  • 递归的逻辑是：先做单层判断，在满足条件的请况进入下层循环时，才做递归

C++代码

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

立夏满晴天
关注
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值