代码随想录算法训练营第十五天|102. 二叉树的层序遍历等十道题、226. 翻转二叉树、101. 对称二叉树

最新推荐文章于 2024-07-10 11:04:17 发布
最新推荐文章于 2024-07-10 11:04:17 发布
阅读量63 收藏
点赞数
文章标签： 算法 leetcode 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fan15157721331/article/details/129268278
版权
文章详细介绍了使用迭代和递归方法解决LeetCode上的多个二叉树问题，包括层序遍历、右视图、层平均值等，提供了详细的解题思路和代码实现。
摘要由CSDN通过智能技术生成

代码随想录刷题02.27

二叉树相关操作2

LeetCode题目

102. 二叉树的层序遍历

解题思路

1.迭代法：

1)二叉树的迭代遍历要依赖栈/队列等数据结构，并且迭代过程也是针对的栈/队列这些数据结构；

2)本题的思路是根节点出栈时向队列中入子节点；

3)注意剪枝情况，当根节点为空时，要避开操作node->right这类操作。

2.递归法：

1）本体的递归思路：

i）共三个形参，root、depth和二维动态数组result，其中，向上传递root、depth，所需要的result一直

存结果；

ii）终止边界条件仍然是当节点root==nullptr时；

iii）当result.size()==depth时，向result数组中加入空的一维数组，否则将对应的节点数据存

result[depth]中。

代码过程
/**
 * 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 {
    void order(TreeNode* root,vector<vector<int>>&result,int depth){
        if(root==nullptr)return;
        if(result.size()==depth)result.push_back(vector<int>());
        result[depth].push_back(root->val);
        order(root->left,result,depth+1);
        order(root->right,result,depth+1);
    }
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        int depth=0;
        vector<vector<int>>result;
        order(root,result,depth);
        return result;
        /*queue<TreeNode*>que;
        vector<vector<int>>result;
        que.push(root);
        while(!que.empty())
        {
            int size=que.size();
            vector<int>vec;
            while(size--)
            {
                TreeNode* node=que.front();
                que.pop();
                if(node==nullptr)continue;
                if(node->left)que.push(node->left);
                if(node->right)que.push(node->right);
                vec.push_back(node->val);
            }
            if(vec.empty())continue;
            result.push_back(vec);
        }
        return result;*/
    }
};

LeetCode题目

107. 二叉树的层序遍历 II

解题思路
代码过程
/**
 * 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;
        vector<vector<int>>result;
        if(root==nullptr)return{};
        que.push(root);
        while(!que.empty())
        {
            int size=que.size();
            vector<int>vec;
            while(size--)
            {
                TreeNode* node=que.front();
                que.pop();
                if(node->left)que.push(node->left);
                if(node->right)que.push(node->right);
                vec.push_back(node->val);
            }
            result.push_back(vec);
        }
        reverse(result.begin(),result.end());
        return result;
    }
};

LeetCode题目

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) {
        queue<TreeNode*>que;
        vector<int>result;
        if(root==nullptr)return{};
        que.push(root);
        while(!que.empty())
        {
            int size=que.size();
            vector<int>vec;
            while(size--)
            {
                TreeNode* node=que.front();
                que.pop();
                if(node->left)que.push(node->left);
                if(node->right)que.push(node->right);
                vec.push_back(node->val);
            }
            result.push_back(*(vec.end()-1));
        }
        return result;
    }
};

LeetCode题目

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) {
        queue<TreeNode*>que;
        vector<double>result;
        if(root==nullptr)return{};
        que.push(root);
        while(!que.empty())
        {
            int size=que.size();
            double sum=0.0;
            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);
                sum+=node->val;
            }
            result.push_back(sum/size);
        }
        return result;
    }
};

LeetCode题目

429. N 叉树的层序遍历

解题思路

**小tips:*构造N叉树，可以把子节点地址存储到一个数组vector<Node>中。

代码过程
/*
// 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;
        vector<vector<int>>result;
        if(root==nullptr)return{};
        que.push(root);
        while(!que.empty())
        {
            int size=que.size();
            vector<int>vec;
            while(size--)
            {
                Node* node=que.front();
                que.pop();
                vec.push_back(node->val);
                for(int i=0;i<(node->children.size());i++)
                {
                    if(node->children[i]!=nullptr)
                        que.push(node->children[i]);
                }
            }
            result.push_back(vec);
        }
        return result;
    }
};

LeetCode题目

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

解题思路

1.找到一个最小值（而不是给整个数列排序的话）可以额外设置一个变量，将变量与数列中数进行比较即可；

2.表示最小值：INT_MIN;表示最大值：INT_MAX

代码过程
/**
 * 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) {
        queue<TreeNode*>que;
        vector<int>result;
        if(root==NULL)return{};
        que.push(root);
        while(!que.empty())
        {
            int size=que.size();
            int resultmax=INT_MIN;
            while(size--)
            {
                TreeNode* node=que.front();
                que.pop();
                resultmax=resultmax>node->val?resultmax:node->val;
                if(node->left)que.push(node->left);
                if(node->right)que.push(node->right);
            }
            result.push_back(resultmax);
        }
        return result;
    }
};

LeetCode题目

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

解题思路

要点：抓住queue的出队和进队来分析

代码过程
/*
// 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)return{};
        que.push(root);
        while(!que.empty())
        {
            int size=que.size();
            for(int i=0;i<size;i++)
            {
                Node* node=que.front();
                que.pop();
                if(i==(size-1))node->next=nullptr;
                else node->next=que.front();
                if(node->left)que.push(node->left);
                if(node->right)que.push(node->right);
            }
        }
        return root;
    }
};

LeetCode题目

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

解题思路
代码过程
/*
// 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)return{};
        que.push(root);
        while(!que.empty())
        {
            int size=que.size();
            for(int i=0;i<size;i++)
            {
                Node* node=que.front();
                que.pop();
                if(i==(size-1))node->next=nullptr;
                else node->next=que.front();
                if(node->left)que.push(node->left);
                if(node->right)que.push(node->right);
            }
        }
        return root;
    }
};

LeetCode题目

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) {
        queue<TreeNode*>que;
        int count=0;
        if(root==NULL)return{};
        que.push(root);
        while(!que.empty())
        {
            int size=que.size();
            int resultmax=INT_MIN;
            while(size--)
            {
                TreeNode* node=que.front();
                que.pop();
                resultmax=resultmax>node->val?resultmax:node->val;
                if(node->left)que.push(node->left);
                if(node->right)que.push(node->right);
            }
            count++;
        }
        return count;        
    }
};

LeetCode题目

111. 二叉树的最小深度

解题思路
代码过程
/**
 * 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) {
        queue<TreeNode*>que;
        int count=0;
        if(root==NULL)return{};
        que.push(root);
        while(!que.empty())
        {
            int size=que.size();
            count++;
            while(size--)
            {
                TreeNode* node=que.front();
                que.pop();
                if(node->left)que.push(node->left);
                if(node->right)que.push(node->right);
                if(node->left==nullptr&&node->right==nullptr)return count;
            }
        }
        return count; 
    }
};

LeetCode题目

226. 翻转二叉树

解题思路

1.针对本题，无论是递归法还是迭代法，都是要“拿出1个节点，然后用swap函数反转其子节点”；

2.用递归法时，抓住输入与返回的形参以及执行的操作，要能构思出如何搭建出“递归梯子”，还要注意单个递归体再递归中的演化效果；

代码过程
/**
 * 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) {
        //递归法
        if(root==nullptr)return root;
        swap(root->left,root->right);
        invertTree(root->left);
        invertTree(root->right);
        return root;
        //迭代法
        /*stack<TreeNode*>st;
        if(root==NULL)return root;
        st.push(root);
        while(!st.empty())
        {
            int size=st.size();
            while(size--)
            {
                TreeNode*node=st.top();
                swap(node->left,node->right);
                st.pop();
                if(node->left)st.push(node->left);
                if(node->right)st.push(node->right);
            }
        }
        return root;*/
    }
};

LeetCode题目

101. 对称二叉树

解题思路

递归书写思路：

1）形参如何确定：需要确定输入形参和返回形参，可能需要多次调试；

2）终止条件如何写：排除上一层终止条件即可进入下一层；

3）递归体如何书写：进入子层（二叉树里面就是2个子层），确定返回条件；

代码过程
/**
 * 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 travel(TreeNode*left,TreeNode*right)
    {
        if(left==nullptr&&right==nullptr)return true;
        else if(left==nullptr&&right!=nullptr)return false;
        else if(left!=nullptr&&right==nullptr)return false;
        else if(left->val!=right->val)return false;
        else{
            bool outside=travel(left->right,right->left);
            bool inside=travel(left->left,right->right);
            bool result=outside&&inside;
            return result;
        }
    }
    bool isSymmetric(TreeNode* root) {
        bool result=travel(root->left,root->right);
        return result;
    }
};
fan15157721331
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
代码随想录算法训练营第十五天[二刷]|102.二叉树的层序遍历.226.翻转二叉树.101. 对称二叉树
MRmaand12的博客
12-11 206
代码随想录算法训练营第十五天
代码随想录算法训练营第15天 | LeetCode 102. 二叉树的层序遍历，226.翻转二叉树，101.对称二叉树
a976903676的博客
11-09 189
LeetCode 102. 二叉树的层序遍历，226.翻转二叉树，101.对称二叉树
代码随想录算法训练营第15天|102.二叉树层序遍历、层序遍历类型题目、226.翻转二叉树、101.对称二叉树
evelynancyyy的博客
03-03 1052
其实方法三和方法四（队列和栈）本质上都是通过可存储的数据结构来暂存待处理的节点，主要是要确定入队列/栈的顺序，对于每层结点，提前统计当前queue中的元素个数size，然后用for循环遍历这size个元素。：（单纯的“优先向右遍历”是不行的，必须要层序遍历！）层序遍历，输出每层的最后一个元素。注：要事先记录下queue的size，因为que.size()在之后的过程中会改变！层序遍历，并用deque来记录每层节点，然后判断deque是否对称。：层序遍历，记录每层的和，和每层节点个数size。
代码随想录算法训练营第十五天|102.二叉树的层序遍历 226.翻转二叉树 101. 对称二叉树
滋滋牛排味的博客
05-23 277
踩坑：先看的视频，没踩什么坑思路：核心是使用队列并记录每一行的size，在遍历本行的时候下一行就入队了。
102二叉树的层序遍历.js
09-22
前端算法 二叉树的层序遍历通过DFS或BFS遍历，依次遍历二叉树遍历的结果值。队列满足先进先出的要求,出列就，新的层进来，旧的层出来
Heyinsen#LeetcodeOrPat#102. 二叉树的层序遍历1
07-25
c++如果构造函数中的所有参数都有默认值，那么不需要再添加无参构造函数层次遍历的话设置一个队列依次压入队列不断的扩展节点就好了，值得注意的是不要把NULL压入队
python-leetcode面试题解之第102题二叉树的层序遍历-题解.zip
04-29
本题解将详细探讨Python实现的LeetCode第102题——二叉树的层序遍历。层序遍历，也称为广度优先搜索（BFS），是处理二叉树问题的一种常见策略。 **二叉树的概念** 二叉树是一种特殊的图结构，每个节点最多有两个子...
java-leetcode题解之第102题二叉树的层序遍历.zip
06-18
本题是LeetCode中的第102题，名为“二叉树的层次遍历”（Level Order Traversal）。在Java中解决这个问题涉及到数据结构和算法的知识，特别是树的遍历和队列的应用。 二叉树是一种特殊的图结构，每个节点最多有两个...
leetcode-4.28[107. 二叉树的层次遍历 II、101. 对称二叉树、104. 二叉树的最大深度]（python解法）
01-20
题目1 原创文章 81获赞 40访问量 3万+ 关注 私信 展开阅读全文 作者：Leadingme
【代码随想录_Day27】509 斐波那契数 70 爬楼梯 746 使用最小花费爬楼梯
qq_43671872的博客
07-08 861
509 斐波那契数70 爬楼梯746 使用最小花费爬楼梯今天的题目难度不低，尽量还是写一些简洁代码 ^ _ ^
十一、作业
weixin_58543820的博客
07-07 494
计算1/1-1/2+1/3-1/4+1/5 ……+ 1/99 - 1/100 的值，打印出结果。编写程序数一下 1到 100 的所有整数中出现多少个数字9。要求：找到了就打印数字所在的下标，找不到则输出：找不到。写一个代码打印1-100之间所有3的倍数的数字。编写代码在一个整形有序数组中查找具体的某个数。打印1000年到2000年之间的闰年。写代码将三个整数数按从大到小输出。给定两个数，求这两个数的最大公约数。最小公倍数=a*b/最大公约数。在屏幕上输出9*9乘法口诀表。%-2d - 左对齐。
每周算法：无向图的双连通分量
少儿编程乔老师
07-06 1240
通过Tarjan算法求无向连通图的双连通分量，计算至少添加多少条边可以将原图变为一个双连通分量。
【算法笔记自学】第 5 章 入门篇（3）——数学问题
qq_62704693的博客
07-06 2029
【代码】【算法笔记自学】入门篇（3）——数学问题。
算法库应用--Brute - Force算法串匹配(顺序串)
qq_57484399的博客
07-06 944
V1.0: 在原有的博客基础上, 加入我构建的算法库, 让博客更完全 , 代码可以运行看效果, 不是让算法仅仅停留在 逻辑方面, 这也是后续我努力的方向, 把这些算法模型, 尽可能的去运用到实际的嵌入式项目中, 把理论变成实物 , 本次也进行了名字优化, 让逻辑更清晰。利用B-f算法,寻找子串在母串中的位置。
力扣215 数组中第k大的数
最新发布
东篱君的博客
07-10 163
算法：由于数组最大范围是10000，存在负数。申请一个20000的数组，将原数组的数作为新数组下标（+10000因为存在负数），然后从后往前减，求出第K大的数。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。本题主要考察各种排序算法，要求时间O（n），严格意义上说只有计数排序满足条件。给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。
《算法笔记》总结No.4——散列
前端，算法，MATLAB，统计学爱好者，目前主攻Web全栈+考研内容
07-07 727
散列的英文名是hash，即我们常说的哈希~该知识点在王道408考研的教材里面属于的范围。即便各位并无深入了解过，也听说过散列是一种更高效的查找方法。
【代码随想录算法训练营第六十二天|卡码网53.寻宝（prim算法和kruskal算法）】
weixin_46281930的博客
07-09 442
kruskal算法以边为导向，先把边按照长度从小到大排序，然后一个个检查边的两个端点是否在同一个集合中（这里使用并查集判断），在同一个集合中就不加入这个边，不在的话就加入。可以把所有已经使用过的结点看作一个整体，然后把他们相接的结点的结点顶点边中进行选择，选择最短的一条边把该结点入树，某种程度来说也是一种贪心？1.选择当前最短入树结点；3.更新结点距离最小生成树的距离。
二分查找2
qq_45965652的博客
07-06 1033
二分查找问题总结2。
代码随想录刷题训练营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、付费专栏及课程。

余额充值