二叉树层序遍历的几个力扣例题

the_singular

已于 2022-07-19 22:06:50 修改

阅读量966

点赞数 2

分类专栏：数据结构与算法文章标签： c++

于 2022-04-05 22:38:49 首次发布

本文链接：https://blog.csdn.net/the_singular/article/details/123685851

版权

数据结构与算法专栏收录该内容

32 篇文章 0 订阅

订阅专栏

记录新手小白的做题过程。

题目1：102.二叉树的层序遍历

题目：给你二叉树的根节点 root ，返回其节点值的 层序遍历 。（即逐层地，从左到右访问所有节点）。

第一次接触层序遍历，还以为很简单，一看题目发现是中等难度的题目。

广度优先搜索

不知道广度优先搜索是什么，所去搜查了一下。

广度优先搜索

所以层序遍历就是将不同的层按顺序放入一个位置，然后依次遍历层数。

官方代码：

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector <vector <int>> ret;//创建vector记录层数中的数，每一层数不止一个，所以ret的元素是rector
        if (!root) {//根结点不为空
            return ret;
        }

        queue <TreeNode*> q;//遍历，一端进一端出保留顺序
        q.push(root);//放入根结点，准备遍历第一层
        while (!q.empty()) {//队列不为空
            int currentLevelSize = q.size();//获取最新一层的元素个数
            ret.push_back(vector <int> ());//想一想，这个用于存放什么？//存放的是最新一层的数据
            for (int i = 1; i <= currentLevelSize; ++i) {//一共取那么多次，都是上一次放进来的那么多个元素，即现在的最新一层
                auto node = q.front(); q.pop();//取出队列第一个，遍历最新一层
                ret.back().push_back(node->val);//放入它的数据//看看这行代码怎么写的，ret的最后一个vector(即在for循环前加入的vector，用于存放最新一层数据).push_back()
                if (node->left) q.push(node->left);//将最新一层的下一层放如队列
                if (node->right) q.push(node->right);//且要注意判断不为空
            }
        }
        
        return ret;
    }
};

看官方解释没有看懂，自己琢磨一下，做了个啰里啰唆的注释。

大概就是放入队列的元素是按批次进行的，每次放入一层，在队列取出父结点后，将它不为空的左右子节点进栈，而它自己的数值放入在循环之前创建的vector中

这种存一层，取一层的方法节约了空间

记录自己打代码时犯的错误：

1、在进入将根结点放入队列前，没有判断根结点是否为0,队列的放入是push

2、在for循环前放入vector是这么写的：ret.push_back(vector <int> ());

vector<int>后还有一个括号

3、ret.back().push_back(node->val);//放入元素，不要忘记back是个函数，它的后面有个括号

题目 2.二叉树的层序遍历2

题目：给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

思路：掌握了层序遍历后，想要从下至上？Maybe，reverse(ret.begin(),ret.end())从上到下的遍历的数组？

题目3： 199.二叉树的右视图

在完整的遍历里，我们每过一次循环就要往队列里放一次数据，而依照题目要求，我们只要放这次循环的最后一个数字就可以了。

for(int i=0;i<len;i++){
                TreeNode* p=que.front();
                que.pop();
                if(i==len-1)//每次都取，但只放进去一个
                    ret.push_back(p->val);
                if(p->left) que.push(p->left);
                if(p->right) que.push(p->right);
            }

题目4 ：637.二叉树的平均值

这个题目也很好想。将操作改一下就可以了。

while(!que.empty()){
            double len=que.size();
            double sum=0;
            for(int i=0;i<len;i++){
                TreeNode* p=que.front();que.pop();
                sum+=p->val;
                if(p->left) que.push(p->left);
                if(p->right) que.push(p->right);
            }
            ret.push_back(sum/len);
        }

题目5： 429.N叉树的层序遍历

题目：

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。

树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

思路：这个题看懵我了，最重要的就是在不确定子结点数量的情况下将子结点全部装入队列中。不过题目已经给出了孩子结点的数组，只要要创建一个循环把子结点装进去就好了。

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>> ret;
        if(root==nullptr) return ret;
        queue<Node*> que;
        que.push(root);
        while(!que.empty()){
            int len=que.size();
            vector<int> cur;
            for(int i=0;i<len;i++){
                Node* p=que.front();
                que.pop();
                cur.push_back(p->val);
                for(auto& ch:p->children){
                    que.push(ch);
                }
            }
            ret.push_back(cur);
        }
        return ret;
    }
};

补充一个知识点：

关于vector的删除方式

题目6：515.在每个树行中找最大值

思路：感觉也很简单，换一下循环内的操作就好了。

for(int i=0;i<len;i++){
                TreeNode* p=que.front();que.pop();
                if(p->val>max)
                    max=p->val;
                if(p->left) que.push(p->left);
                if(p->right) que.push(p->right);
            }

题目7：116.填充每个右节点

题目：

给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。


        while(!que.empty()){
            int len=que.size();
            Node* p;
            for(int i=0;i<len;i++){
                if(i==0){
                    p=que.front();
                    que.pop();
                }
                else{
                    Node* q=que.front();
                    que.pop();
                    p->next=q;
                    p=q;
                }
                if(p->left) que.push(p->left);
                if(p->right) que.push ( p -> right);
            }
        }

注意队列是push，push!它只有一端能进，所以不是push_back

题目8：117.填充每个节点的下一个右侧结点

题目：

给定一个二叉树

struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

跟上一题也没差吧？

题目9：104、二叉树的最大深度

题目：

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

思路：感觉这个就在外圈循环加一个记录的数字就好了。

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root==nullptr) return 0;
        queue<TreeNode*> que;
        int i=0;
        que.push(root);
        while(!que.empty()){
            int len=que.size();
            i++;
            for(int j=0;j<len;j++){
                TreeNode* p=que.front();
                que.pop();
                if(p->left) que.push(p->left);
                if(p->right) que.push(p->right);
            }
        }
        return i;
    }
};

递归法：官方代码

点击链接

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == nullptr) return 0;
        return max(maxDepth(root->left), maxDepth(root->right)) + 1;
    }
};

卧槽，太妙了，每个结点都取它的最长子树距离。因为是从父结点的子结点开始的，所以后面需要加1算上这个递归内的一个父结点

题目10：111.二叉树的最小深度

题目：

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明：叶子节点是指没有子节点的节点。

思路：感觉这个emmm，最小深度，是将空也放入队列中，然后像上一题一样记录层数，若遇到空，就直接返回层数。

上面的思路是错误的，应该是在放结点入队列的最后再判断一下是否两个子结点都为空，都为空说明遇到叶子结点了，就返回层数。

class Solution {
public:
    int minDepth(TreeNode* root) {
        if(root==nullptr) return 0;
        queue<TreeNode*> que;
        int i=0;
        que.push(root);
        while(!que.empty()){
            int len=que.size();
            i++;
            for(int j=0;j<len;j++){
                TreeNode* p=que.front();
                que.pop();
                if(p->left) que.push(p->left);
                if(p->right) que.push(p->right);
                if(p->left==nullptr&&p->right==nullptr)
                    return i;
            }
        }
        return i;
    }
};

好了，题目说难也不难，不过问题是是否能在遇到这一类问题时想起来可以用层序遍历。

下一题！