代码随想录算法训练营第17期第15天 | 层序遍历 、226. 翻转二叉树、101. 对称二叉树

已于 2023-07-20 23:09:23 修改
阅读量87 收藏
点赞数
文章标签： 算法 leetcode 数据结构
于 2023-07-17 02:21:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qyy123ise/article/details/131757699
版权

目录

102. 二叉树的层序遍历

107. 二叉树的层序遍历 II

199. 二叉树的右视图

637. 二叉树的层平均值

429. N 叉树的层序遍历

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

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

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

104. 二叉树的最大深度

111. 二叉树的最小深度

226. 翻转二叉树

101. 对称二叉树

102. 二叉树的层序遍历

这里要用双端队列，queue，队列里面的值类型是TreeNode*，queue的用法见第十天，这里用while比for好像快一点

/**
 * 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;
        vector<vector<int>> res;
        if (root != nullptr){
            que.push(root);
        }
        while (!que.empty()){
            int cnt = que.size();
            vector<int> vtmp;
            while (cnt--){
                TreeNode* tmp = que.front();
                vtmp.push_back(tmp->val);
                que.pop();
                if (tmp->left != nullptr) que.push(tmp->left);
                if (tmp->right != nullptr) que.push(tmp->right);
            }
            res.push_back(vtmp);
        }
        return res;
    }
};
107. 二叉树的层序遍历 II

 最后一步reverse即可得到自底向上的层序遍历

/**
 * 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) {
        vector<vector<int>> res;
        queue<TreeNode*> que;
        if (root != nullptr){
            que.push(root);
        }
        while (!que.empty()){
            int cnt = que.size();
            vector<int> vec;
            while (cnt--){
                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);
            }
            res.push_back(vec);
        }
        reverse(res.begin(), res.end());
        return res;
    }
};
199. 二叉树的右视图

 其实是层序遍历每层的最后一个值

/**
 * 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) {
        vector<int> res;
        queue<TreeNode*> que;
        if (root != nullptr){
            que.push(root);
        }
        while (!que.empty()){
            int cnt = que.size();
            while (cnt--){
                TreeNode* node = que.front();
                que.pop();
                if (cnt == 0) res.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return res;
    }
};
637. 二叉树的层平均值

 层序的基础上求平均值

/**
 * 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) {
        vector<double> res;
        queue<TreeNode*> que;
        if (root != nullptr){
            que.push(root);
        }        
        while (!que.empty()){
            double tmp = 0.0;
            int cnt = que.size();
            double div = cnt;
            while (cnt--){
                TreeNode* node = que.front();
                que.pop();
                tmp += node->val;
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            res.push_back(tmp/div);
        }
        return res;
    }
};
429. N 叉树的层序遍历

重点在追加N叉树的孩子的时候，需要一个循环

/*
// 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) {
        vector<vector<int>> res;
        queue<Node*> que;
        if (root != nullptr){
            que.push(root);
        }
        while (!que.empty()){
            int cnt = que.size();
            vector<int> tmp;
            while (cnt--){
                Node* node = que.front();
                que.pop();
                tmp.push_back(node->val);
                for(int i = 0; i < node->children.size(); i++){
                    que.push(node->children[i]);
                }
            }
            res.push_back(tmp);
        }
        return res;
    }
};
515. 在每个树行中找最大值

 每次循环的时候保留最大值即可，不需要再构建一个vector

/**
 * 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> largestValues(TreeNode* root) {
        vector<int> res;
        queue<TreeNode*> que;
        if (root != nullptr){
            que.push(root);
        }
        while (!que.empty()){
            int cnt = que.size();
            int tmp = que.front()->val;
            while (cnt--){
                TreeNode* node = que.front();
                que.pop();
                tmp = (tmp < node->val) ? node->val : tmp;
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            res.push_back(tmp);
        }
        return res;
    }
};
116. 填充每个节点的下一个右侧节点指针

每一级的最后一个节点指向NULL，其他节点指向队列的front即可

直接在原Node上进行操作，不需要额外构建数据结构

/*
// 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 cnt = que.size();
            while(cnt--){
                Node* node = que.front();
                que.pop();
                if (cnt == 0){
                    node->next = NULL;
                }
                else{
                    node->next = que.front();
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return root;
    }
};
117. 填充每个节点的下一个右侧节点指针 II

 代码和上一题一毛一样，我就不贴了，是不是完美二叉树并不会对解决这个问题造成任何干扰

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 maxDepth(TreeNode* root) {
        int depth = 0;
        queue<TreeNode*> que;
        if (root != nullptr){
            que.push(root);
        }
        while (!que.empty()){
            int cnt = que.size();
            depth++;
            while (cnt--){
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);                
            }            
        }
        return depth;
    }
};
111. 二叉树的最小深度

 当左右孩子都为空的时候，说明遇到了最小深度的层，可以直接return，不过要注意，最后返回的时候需要一个return

/**
 * 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) {
        int min_cnt = 0;
        queue<TreeNode*> que;
        if (root != nullptr){
            que.push(root);
        }
        while (!que.empty()){
            int cnt = que.size();
            min_cnt++;
            while(cnt--){
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
                if (!node->left and !node->right) return min_cnt;
            }
        }
        return min_cnt;
    }
};
226. 翻转二叉树

 在遍历的时间交换两个子节点即可

/**
 * 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:
    TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != nullptr){
            que.push(root);
        }
        while (!que.empty()){
            int cnt = que.size();
            while (cnt--){
                TreeNode* node= que.front();
                que.pop();
                TreeNode* tmp = node->left;
                node->left = node->right;
                node->right = tmp;
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return root;
    }
};

//递归
class Solution {
public:
    void rever(TreeNode* cur){
        if (cur == nullptr){
            return;
        }
        TreeNode* tmp = cur->left;
        cur->left = cur->right;
        cur->right = tmp;
        if (cur->left) rever(cur->left);
        if (cur->right) rever(cur->right);

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

//这里是迭代法，统一迭代还要学习一下
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        stack<TreeNode*> st;
        if (root != nullptr){
            st.push(root);
        }
        while (!st.empty()){
            TreeNode* node = st.top();
            st.pop();
            swap(node->left, node->right);
            if (node->right != nullptr){
                st.push(node->right);
            }
            if (node->left != nullptr){
                st.push(node->left);
            }
        }
        return root;
    }
};
101. 对称二叉树

 判断两个子二叉树是否可以翻转

/**
 * 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:
    bool isSymmetric(TreeNode* root) {
        if (root == nullptr)
            return true;
        queue<TreeNode*> que;
        que.push(root->left);
        que.push(root->right);
        while (!que.empty()){
            TreeNode* left = que.front();
            que.pop();
            TreeNode* right = que.front();
            que.pop();
            if (!left && !right) //左右为空，则彼此堆成
                continue;
            if (!left || !right || (left->val != right->val)) //左右有一不为空，或值不等
                return false;
            que.push(left->left);
            que.push(right->right);
            que.push(left->right);
            que.push(right->left);
        }
        return true;
    }
};

红雪川
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
102二叉树的层序遍历.js
09-22
前端算法 二叉树的层序遍历通过DFS或BFS遍历，依次遍历二叉树遍历的结果值。队列满足先进先出的要求,出列就，新的层进来，旧的层出来
python-leetcode面试题解之第107题二叉树的层序遍历II.zip
04-29
python python_leetcode面试题解之第107题二叉树的层序遍历II
代码随想录算法训练营第十五天| 层序遍历 226.翻转二叉树 101. 对称二叉树
qq_22081185的博客
09-07 81
层序遍历题目链接/文章讲解/视频讲解：https://programmercarl.com/0102.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E5%B1%82%E5%BA%8F%E9%81%8D%E5%8E%86.html226.翻转二叉树 （优先掌握递归）题目链接/文章讲解/视频讲解：https://programmercarl.com/0226.%E7%BF%BB%E8%BD%AC%E4%BA%8C%E5%8F%89%E6%A0%91.html。
代码随想录算法训练营第十五天 | 层序遍历 226.翻转二叉树 101.对称二叉树
zhang1282882326的博客
03-26 557
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为。填充它的每个 next 指针，让这个指针指向其下一个右侧节点。，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。，其所有叶子节点都在同一层，每个父节点都有两个子节点。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。，翻转这棵二叉树，并返回其根节点。叶子节点是指没有子节点的节点。
代码随想录算法训练营第十五天| 层序遍历 226.翻转二叉树 101.对称二叉树
amytheace的博客
05-29 93
这种涉及double的题要格外小心，能在最开始declare variable的时候设成double就直接double，一个是之后运算的时候不用cast，一个是只设置为int可能会溢出。翻转正常层序遍历就行，用 reverse(levelOrder.begin(), levelOrder.end());111. 这道题和104都有两种写的方法，level traverse或者递归遍历，递归遍历以后练。116. 用现在的front() 指向pop后的front()就行。429. 见总套路，记住套路一遍过。
代码随想录算法训练营第十五天 | 层序遍历 226.翻转二叉树 101.对称二叉树 2
a20010616的博客
08-23 66
这道题目 一些做过的同学 理解的也不够深入，建议大家先看我的视频讲解，无论做过没做过，都会有很大收获。看完本篇可以一口气刷十道题，试一试， 层序遍历并不难，大家可以很快刷了十道题。101. 对称二叉树 （优先掌握递归）226.翻转二叉树 （优先掌握递归）先看视频讲解，会更容易一些。
代码随想录算法训练营第15天|层序遍历 226.翻转二叉树 101.对称二叉树 2
weixin_43646251的博客
02-08 149
【代码】代码随想录算法训练营第15天|层序遍历 226.翻转二叉树 101.对称二叉树 2。
代码随想录算法训练营第15日 | 层序遍历 226.翻转二叉树 101.对称二叉树 2
lebowskii的博客
10-06 224
day15
代码随想录算法训练营第15天 | 二叉树层序遍历 226.翻转二叉树 101.对称二叉树
qq_44173169的博客
01-11 396
这样一层一层地遍历就是广度优先搜索，队列先入先出的性质是最合适的。也可以用递归的方法实现，要注意递归函数的传入参数，因为我们是一层一层遍历的，所以应该传入当前节点的所属层次。不需要返回参数，只需要保存结果数组。int。
代码随想录算法训练营第十五天| 层序遍历 ，226.翻转二叉树 ，101.对称二叉树
m0_43385261的博客
03-06 132
今日任务层序遍历 ，226.翻转二叉树 ，101.对称二叉树。
代码随想录算法训练营第十五天 | 层序遍历、226.翻转二叉树、101.对称二叉树
owlmo的博客
12-27 1133
然后将当前节点的left指向当前的右子树，right指向当前的左子树，做翻转操作。否则进行递归处理，判断当前对应的两棵子树是否对称，判断的根据还是根据两棵子树是否为空、两棵子树的对称位置子树是否一致等。思路：进行层次遍历，如果在遍历时，发现当前有一个节点既没有左子树又没有右子树，则当前节点的深度为二叉树的最小深度。思路：进行层次遍历，然后对每层的结果做平均，注意每个节点的数值是否越过int的边界。思路：进行层序遍历，然后在遍历的过程中不断地将每层的前一个节点指向后一个节点。给你一个二叉树的根节点。
8606-二叉树的构建及遍历操作.rar_二叉树_遍历算法
09-21
实现二叉树的遍历操作，属于数据结构基础算法，代码能够顺利运行，运行环境是ColdBlick。
二叉树的层序遍历 II.md
11-17
二叉树的层序遍历 II.md
leetcode-4.28[107. 二叉树的层次遍历 II、101. 对称二叉树、104. 二叉树的最大深度]（python解法）
01-20
题目1 原创文章 81获赞 40访问量 3万+ 关注 私信 展开阅读全文 作者：Leadingme
[Easy] leetcode-35 搜索插入位置
最新发布
Sofine
05-09 80
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。利用二分查找可以更快的找到，只需要修改返回值即可，注意获取mid的计算方法考虑了溢出。注意到是按顺序排列的数组，那么按顺序遍历，如果找到，则跳出循环返回索引即可。如果找到最后还没找到，则返回数组长度索引值即为插入位置。
LeetCode 35.搜索插入位置
tus00000的博客
05-08 180
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。输入: nums = [1,3,5,6], target = 5。输入: nums = [1,3,5,6], target = 2。输入: nums = [1,3,5,6], target = 7。此算法时间复杂度为O(logn)，空间复杂度为O(1)。请必须使用时间复杂度为 O(log n) 的算法。nums 为 无重复元素 的 升序 排列数组。
【算法】高精度乘法
m0_73209194的博客
05-02 518
高精度乘法
C++类和对象（下）（2）
2302_79331124的博客
05-02 786
关于类和对象的内容，至此就结束了，希望大家能从这几篇博客中对类和对象有更加深刻的认识，接下来会继续更新C++的内容。
代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿
09-23
引中提到，二叉树的层序遍历可以通过DFS或BFS来实现。其中，BFS是利用队列的先进先出特性来实现的，每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列。 引用中给出了一个实现翻转二叉树的代码示例...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值