代码随想录一刷打卡——二叉树的层次遍历（十题特别版）

已于 2023-09-19 09:23:49 修改
阅读量75 收藏
点赞数
分类专栏： 代码随想录刷刷刷 文章标签： 学习 程序人生 c++ leetcode
于 2023-09-15 11:04:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43264167/article/details/132823210
版权

文章目录

前言

一个本硕双非的小菜鸡，备战24年秋招，计划刷完卡子哥的刷题计划，加油！
推荐一手卡子哥的刷题网站，感谢卡子哥。代码随想录

一、102. 二叉树的层序遍历

Note：层序遍历又称广度优先搜索，一层层的将数据打印出来，使用的是队列操作。


/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
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;

            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

107. 二叉树的层序遍历 II

Note：正常遍历之后翻转一下


/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrderBottom(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;

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

三、637. 二叉树的层平均值

637. 二叉树的层平均值

Note：就是层序遍历加了个求平均

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<double> result;

        while (!que.empty()) {
            int size = que.size();
            double sum = 0;

            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                sum += node->val;
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(sum / size);
        }
        return result;
    }
};

四、429. N 叉树的层序遍历

429. N 叉树的层序遍历

Note：一样是模板题，只不过由left和right变成了children

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        if (!root) {
            return {};
        }

        vector<vector<int>> ans;
        queue<Node*> q;
        q.push(root);

        while (!q.empty()) {
            int cnt = q.size();
            vector<int> level;
            for (int i = 0; i < cnt; ++i) {
                Node* cur = q.front();
                q.pop();
                level.push_back(cur->val);
                for (Node* child: cur->children) {
                    q.push(child);
                }
            }
            ans.push_back(move(level));
        }

        return ans;
    }
};

第二种写法

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        queue<Node*> que;
        if (root != NULL) que.push(root);
        vector<vector<int>> result;

        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            for (int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                vec.push_back(node->val)
                for (int i = 0; i < node->children.size(); i++) {
                    if (node->children[i]) que.push(node->children[i]);
                }
            }
            result.push_back(vec);
        }
        return result;
    }
};

五、199. 二叉树的右视图

Note：也是层序遍历的一种

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<int> result;

        while (!que.empty()) {
            int size = que.size();

            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (i == (size - 1)) result.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return result;
    }
};

六、515. 在每个树行中找最大值

Note：模板题+1，每次取个最大值就好了


/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
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;

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

七、116. 填充每个节点的下一个右侧节点指针

Note：定义俩指针，记录并传递


/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            Node* nodePre;
            Node* node;

            for (int i = 0; i < size; i++) {
                if (i == 0) {
                    nodePre = que.front();
                    que.pop();
                    node = nodePre;
                } else {
                    node = que.front();
                    que.pop();
                    nodePre->next = node;
                    nodePre = nodePre->next;
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            nodePre->next = NULL;
        }
        return root;
    }
};

八、117. 填充每个节点的下一个右侧节点指针 II

Note：定义俩指针，记录并传递


/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            vector<int> vet;
            Node* nodePre;
            Node* node;

            for (int i = 0; i < size; i++) {
                if (i == 0) {
                    nodePre = que.front();
                    que.pop();
                    node = nodePre;
                } else {
                    node = que.front();
                    que.pop();
                    nodePre->next = node;
                    nodePre = nodePre->next;
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            nodePre->next = NULL;
        }
        return root;
    }
};

九、104. 二叉树的最大深度

Note：也是一道模板题

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == NULL) return 0;
        int depth = 0;

        queue<TreeNode*> que;
        que.push(root);

        while(!que.empty()) {
            int size = que.size();
            depth++;

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

十、111. 二叉树的最小深度

Note：只需要在104题的基础上增加左右孩子都为空的判断就成


/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int minDepth(TreeNode* root) {
        if(root == NULL) return 0;
        int depth = 0;
        queue<TreeNode*> que;
        que.push(root);

        while (!que.empty()) {
            int size = que.size();
            depth++;

            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);
                if (!node->left && !node->right) return depth;
            }
        }
        return depth;
    }
};

总结

我要打十个！

努力找工作的小菜鸡
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
LeetCode 算法题库【94】——二叉树的中序遍历
12-21
二叉树的中序遍历 题目描述： 解题思路： 第一种：递归。又是递归，可以发现很多题都可以用到递归的思路…。二叉树的中序遍历，这里不太了解的可以看看这个博客：二叉树遍历，总结了二叉树的所有遍历情况。这道题所...
二叉树层次遍历.rar
04-15
数据结构课程设计实例二叉树层次遍历 数据结构课程设计实例二叉树层次遍历 数据结构课程设计实例二叉树层次遍历 数据结构课程设计实例二叉树层次遍历 数据结构课程设计实例二叉树层次遍历 数据结构课程设计实例...
数据结构实验3 二叉树层次遍历 二叉树的层次遍历
07-05
层次遍历是二叉树的一种遍历方式，即从左到右，从上到下依次访问每个节点。 实验目的： （1）了解二叉树结构层次遍历概念； （2）理解二叉树二种不同层次遍历过程； （3）掌握二叉树层次遍历算法程序。 实验内容...
数据结构实验——二叉树的建立和遍历.zip
12-13
1.采用二叉链表作为存储结构，创建一棵二叉树； 2.用递归及非递归算法对二叉树实现先序遍历； 3.用递归及非递归算法对二叉树实现中序遍历； 4.用递归及非递归算法对二叉树实现后序遍历。 5.用递归遍历算法中的访问...
十大成长型思维：定位思维、商业思维、时间管理思维、学习成长思维、精力管理思维、逻辑表达思维、聚焦思维、金字塔原理、目标思维、反思思维
limengshi138392的博客
06-15 1081
十大成长型思维：定位思维、商业思维、时间管理思维、学习成长思维、精力管理思维、逻辑表达思维、聚焦思维、金字塔原理、目标思维、反思思维
【电子信息工程专业课】学习记录
共同进步！
06-12 327
- # **数字信号处理** * ## 离散时间信号与系统 + ### 周期延拓 一个连续时间信号经过理想采样后，其频谱将沿着频率轴以采样频率Ωs = 2π / T 为间隔而重复。 + ### 混频 各周期的延拓分量产生频谱交替的现象 + ### 奈奎斯特采样定理 fs > 2fh
Qt---pro文件的学习
weixin_51883798的博客
06-11 504
【代码】Qt---pro文件的学习。
怎么学习汇川Codesys PLC教程？
NAV3055的博客
06-12 330
各位好，我在B站和抖音上都有发布视频的，搜索我的名称“阿凡工控分享”即可。在CSDN上发表文章也是想把我的一点见解和经验分享出来，进一步的方便大家进行学习。
CNN学习（7）：用C++实现简单不同参数的卷积模型
共同学习，共同进步。
06-15 949
几类简单的卷积操作及可执行程序。
eNSP学习——配置前缀列表
TXFBAP的博客
06-11 1065
理解前缀列表的应用场景 掌握前缀列表的配置方法 理解前缀列表与ACL的区别
安卓网络编程主要学习什么：深度解析与实用指南
asdgftv_niiy的博客
06-16 301
综上所述，安卓网络编程主要学习网络基础知识、安卓网络编程框架、异步处理与网络线程以及安全性与错误处理等方面。掌握这些知识，可以帮助开发者更好地应对网络编程中的各种挑战和问题，提升应用的性能和用户体验。当然，随着技术的不断发展，安卓网络编程领域也在不断更新和演进，开发者需要保持持续学习的态度，不断跟进新的技术和趋势。这些框架封装了底层的网络请求和响应处理逻辑，简化了网络编程的复杂度。在网络编程中，安全性和错误处理同样不可忽视。同时，还需要学习如何处理网络请求中的错误和异常情况，确保应用的稳定性和可靠性。
扩展学习|政策设计的相关内容整理
最新发布
weixin_63253486的博客
06-18 665
本文围绕cssci来源期刊的文献，整理了关于公共政策设计的相关内容，并从多个维度理解政策设计的发展脉络、现有流派以及历来研究重心。
【perfetto分析性能学习笔记】
q_2474932226的博客
06-12 311
perfrtto性能分析
样本学习：当AI遇上“少见多怪”
山石网科的博客
06-13 774
从生物学的角度来看，我们的大脑是如何在经历了少数几次的经验后，形成对事物的认识和理解的？为了实现这样的元学习，有几种流行的方法，例如模型无关的元学习（MAML），它通过优化一个模型的初始参数，以确保这些参数可以通过少量的梯度更新迅速适应新任务。只有这样，通过增强后的数据训练出的模型，才能在现实世界中遇到新数据时，表现出良好的鲁棒性和适应性。嵌入学习是机器学习中一种将高维数据转换到低维空间的技术，它尝试揭示数据背后的隐含结构，使得数据的某些特性（如类别间的相似性或差异性）在新的空间中更加明显。
大模型学习之GLM结构
qq_38915354的博客
06-11 1088
随着人工智能技术的不断进步，自然语言处理（NLP）领域也迎来了革命性的发展。OpenAI的ChatGPT及其后续产品在全球范围内引起了广泛关注，展示了大型语言模型（LLM）的强大能力。在这一背景下，GLM（General Language Model）作为一种创新的预训练语言模型，以其独特的自编码和自回归结合的训练方法，为NLP领域带来了新的视角。
linux驱动学习（十二）之看门狗
ckg3824278的博客
06-12 168
linux驱动学习（十一）之看门狗
Ui学习--UITableView
2301_80253909的博客
06-16 393
UITableView的简单学习～
AUTOSAR学习
Dr_chaser的博客
06-12 649
前段时间参加系统架构师的软考，其中案例分析中的嵌入式题目是分析autosar架构，但是自己只是听说过汽车领域正在使用这个架构，实际上这个架构到底是什么？以及它有什么作用，则是全然不知，最终作为一个嵌入式工程师，案例题也没有选择这个嵌入式题目。其实软考会考这个东西再一定层面上就说明，国家或者当前社会这块的人才是有些稀缺的，然后想通过这种软考让更多的人去了解autosar架构。另外最近在看机器人领域的工作，发现和ROS（机器人操作系统）相关的开发工作中很多都提到了要对autosar有一定的了解。
CCAA质量管理【学习笔记】​​ 备考知识点笔记（六）质量改进系统方法与工具
喃喃不爱说话的博客空间
06-15 1053
六西格玛是20世纪80年代，由美国摩托罗拉公司所开发的质量改进方法，其源于统计原理，是一套 系统的、集成的业务改进方法体系，旨在通过严谨的流程和科学的方法实现组织业务流程突破性改进和设 计创新，减少变异，消除浪费，提高质量和效率，提升顾客和利益相关方满意的系统化、结构化的业务改进与创新模式。六西格玛管理在杰克.韦尔奇的推动下，在通用电气获得巨大成功，成为该公司提高企业业绩与竞争力 的核心管理模式之一。而戴尔、西门子等众多跨国企业多年的实践也证明，六西格玛管理是卓有成效的，
二叉树层次遍历输出代码
03-12
以下是一个示例的二叉树层次遍历输出的代码： ```python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right def levelOrder(root): ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

努力找工作的小菜鸡

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值