二叉树层序遍历与相应题目

kirei12315

已于 2023-02-19 17:00:28 修改

阅读量44

点赞数

分类专栏：二叉树文章标签： leetcode Powered by 金山文档

于 2023-01-29 12:46:39 首次发布

本文链接：https://blog.csdn.net/kirei12315/article/details/128785674

版权

二叉树专栏收录该内容

14 篇文章 0 订阅

订阅专栏

https://leetcode.cn/problems/binary-tree-level-order-traversal/（leetcode题目链接）

给出一个二叉树，要求按照一层一层的顺序进行遍历，返回遍历所得到的节点数值。也就是说层序遍历要求从左到右一层一层的遍历二叉树，需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

代码如下：

class Solution{
    public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;//要求用二维数组存储
        queue<TreeNode*> que;
        
        if(root == nullptr) return result;
        que.push(root);
        
        while(!que.empty()){
            vector<int> vec;
            int size = que.size();//一定要在每一层循环前确定size的大小，从而不会再循环中改变
        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;
}
};

二叉树的层次遍历 II

https://leetcode.cn/problems/binary-tree-level-order-traversal-ii/

给定一个二叉树，返回其节点值自底向上的层次遍历。（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

解答思路很简单，就是用reverse函数对result进行一下反转即可。

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;

    }
};

199.二叉树的右视图

https://leetcode.cn/problems/binary-tree-right-side-view/

给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

第一次看到这个题目的时候，我第一时间考虑的是在层循环中去掉left相关，不就可以只遍历右边了吗，但是后来我想到这个思路完全是错误的，如果左孩子有数值，右孩子没有，这个时候从右边视角看过去，会看到左孩子，所以要考虑其他的方法：

思路如下：我们都知道size大小是某一层进入队列的值的多少，也就是，size = 5的时候，说明这一层有5个进入队列，那么当遍历到地5-1个，也就是i = size - 1；的时候，是不是正在遍历该层最右边的数值呢？所以我们建立一维数组result，只保存i = size - 1的时候的node->val;

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); // 将每一层的最后元素放入result数组中
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return result;
    }
};

637.二叉树的层平均值

https://leetcode.cn/problems/average-of-levels-in-binary-tree/

给定一个非空二叉树, 返回一个由每层节点平均值组成的数组。

思路：针对这个题目，我们的思路也很明确，那就是用sum统计每一层的每个节点的和，然后

除size。注意这里使用double，因为要保留整数，测试例子中有出现14.5，所以不能用int，要用double。

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

N叉树的层序遍历

https://leetcode.cn/problems/n-ary-tree-level-order-traversal/

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

这道题仍然是使用模板，区别是模板中的左孩子右孩子的思路换成了题目中给出的child：

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]);//如果[i]节点有孩子，则将其加入队列
                }
            }
            result.push_back(vec);
        }
        return result;

    }
};

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

https://leetcode.cn/problems/find-largest-value-in-each-tree-row/

您需要在二叉树的每一行中找到最大的值。

思路：每一行中找到最大值，则需要层序遍历后，在每一层进行比较，具体思路可以是：创建一个极小值INT_IN，然后遍历node的值和极小值做比较，最后选出最大的。

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<int> result;
        while (!que.empty()) {
            int size = que.size();
            int maxValue = INT_MIN; // 创立一个最大值参数，给他赋极小值，取每一层的最大值
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                maxValue = node->val > maxValue ? node->val : maxValue;//选出每次层循环中最大的值，也就是每层最大值。
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(maxValue); // 把最大值放进数组
        }
        return result;
    }
};

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

https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/、

仍然有点晕，等慢慢看理解后再补充

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> vec;
            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; // 本层前一个节点next指向本节点
                    nodePre = nodePre->next;
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            nodePre->next = NULL; // 本层最后一个节点指向NULL
        }
        return root;

    }
};

104.二叉树的最大深度

https://leetcode.cn/problems/maximum-depth-of-binary-tree/

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

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

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

思路：层序遍历，然后没循环一等depth++即可

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.二叉树的最小深度

https://leetcode.cn/problems/minimum-depth-of-binary-tree/

思路：判断哪一层左右孩子都为空，然后直接return depth即可

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

kirei12315

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
二叉树层序遍历与相应题目

思路如下：我们都知道size大小是某一层进入队列的值的多少，也就是，size = 5的时候，说明这一层有5个进入队列，那么当遍历到地5-1个，也就是i = size - 1；思路：每一行中找到最大值，则需要层序遍历后，在每一层进行比较，具体思路可以是：创建一个极小值INT_IN，然后遍历node的值和极小值做比较，最后选出最大的。给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。思路：针对这个题目，我们的思路也很明确，那就是用sum统计每一层的每个节点的和，然后。
复制链接

扫一扫