LeetCode二叉树经典题目（六）：层序遍历

Jomo.

已于 2023-01-08 12:44:45 修改

阅读量259

点赞数 1

文章标签： leetcode 算法 c++ 数据结构

于 2023-01-08 08:46:47 首次发布

本文链接：https://blog.csdn.net/m0_60750183/article/details/128598020

版权

4. LeetCode102. 二叉树的层序遍历

5.LeetCode107. 二叉树的层序遍历 II

6. LeetCode199. 二叉树的右视图

7. LeetCode637. 二叉树的层平均值

8. LeetCode429. N 叉树的层序遍历

9. LeetCode515. 在每个树行中找最大值

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

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

14. LeetCode225. 翻转二叉树

4. LeetCode102. 二叉树的层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        if(root==NULL){
            return {};
        }
        queue<TreeNode*>qu;
        qu.push(root);
        vector<vector<int>>res;
        while(!qu.empty()){
            vector<int>vec;//记录每层节点值
            for(int i=qu.size();i>0;i--){
                TreeNode*node=qu.front();
                qu.pop();//注意qu的size是不断变化的
                vec.push_back(node->val);
                if(node->left)qu.push(node->left);
                if(node->right)qu.push(node->right);
            }
            res.push_back(vec);
        }
        return res;
    }
};

5.LeetCode107. 二叉树的层序遍历 II

思路：把从上到下的层序遍历数组反转一下即可
class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        if(root==NULL){
            return {};
        }
        queue<TreeNode*>qu;
        qu.push(root);
        vector<vector<int>>res;
        while(!qu.empty()){
            vector<int>vec;//记录每层节点值
            for(int i=qu.size();i>0;i--){
                TreeNode*node=qu.front();
                qu.pop();//注意qu的size是不断变化的
                vec.push_back(node->val);
                if(node->left)qu.push(node->left);
                if(node->right)qu.push(node->right);
            }
            res.push_back(vec);
        }
        reverse(res.begin(),res.end());
        return res;
    }
};

6. LeetCode199. 二叉树的右视图

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int>res;
        if(root==NULL)return res;
        queue<TreeNode*>qu;
        qu.push(root);
        while(!qu.empty()){
            for(int i=qu.size();i>0;i--){
                TreeNode*node=qu.front();
                qu.pop();
                if(node->left)qu.push(node->left);
                if(node->right)qu.push(node->right);
                if(i==1){
                    res.push_back(node->val);//每层最后一个节点即最右节点
                }
            }
        }
        return res;
    }
};

7. LeetCode637. 二叉树的层平均值

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double>res;
        if(root==NULL)return res;
        queue<TreeNode*>qu;
        qu.push(root);
        while(!qu.empty()){
            double sum=0;
            int size=qu.size();
            for(int i=0;i<size;i++){
                TreeNode*node=qu.front();
                qu.pop();
                sum+=node->val;
                if(node->left)qu.push(node->left);
                if(node->right)qu.push(node->right);
            }
            res.push_back(sum/size);
        }
        return res;
    }
};

8. LeetCode429. N 叉树的层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>>res;
        if(root==NULL)return res;
        queue<Node*>qu;
        qu.push(root);
        while(!qu.empty()){
            vector<int>vec;
            for(int i=qu.size();i>0;i--){
                Node*node=qu.front();
                qu.pop();
                vec.push_back(node->val);
                for(int j=0;j<node->children.size();j++){
                    qu.push(node->children[j]);
                }
            }
            res.push_back(vec);
        }
        return res;
    }
};

9. LeetCode515. 在每个树行中找最大值

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        vector<int>res;
        if(root==NULL)return res;
        queue<TreeNode*>qu;
        qu.push(root);
        while(!qu.empty()){
            int maxVal=INT_MIN;
            for(int i=qu.size();i>0;i--){
                TreeNode*node=qu.front();
                qu.pop();
                maxVal=max(maxVal,node->val);
                if(node->left)qu.push(node->left);
                if(node->right)qu.push(node->right);
            }
            res.push_back(maxVal);
        }
        return res;
    }
};

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

class Solution {
public:
    Node* connect(Node* root) {
        if(root==NULL)return root;
        queue<Node*>qu;
        qu.push(root);
        while(!qu.empty()){
            int size=qu.size();
            Node*pre=NULL;
            Node*cur=NULL;
            for(int i=0;i<size;i++){
                if(i==0){
                    cur=qu.front();
                    qu.pop();
                    pre=cur;
                }else{
                    cur=qu.front();
                    qu.pop();
                    pre->next=cur;
                    pre=pre->next;
                }
                if(cur->left)qu.push(cur->left);
                if(cur->right)qu.push(cur->right);
            }
            cur->next=NULL;
        }
        return root;
    }
};

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

class Solution {
public:
    Node* connect(Node* root) {
         if(root==NULL)return root;
        queue<Node*>qu;
        qu.push(root);
        while(!qu.empty()){
            int size=qu.size();
            Node*pre=NULL;
            Node*cur=NULL;
            for(int i=0;i<size;i++){
                if(i==0){
                    cur=qu.front();
                    qu.pop();
                    pre=cur;
                }else{
                    cur=qu.front();
                    qu.pop();
                    pre->next=cur;
                    pre=pre->next;
                }
                if(cur->left)qu.push(cur->left);
                if(cur->right)qu.push(cur->right);
            }
            cur->next=NULL;
        }
        return root;
    }
};

14. LeetCode226. 翻转二叉树

思路：
只要能遍历二叉树每个节点并交换其左右子节点即可，但是中序遍历例外。
中序遍历顺序：左中右
1.左子节点先交换自己的左右孩子
2.关键：父节点交换自己的左右孩子
3.此时的右子节点是原先的左子节点，其左右孩子被交换两次，而原先左子节点未交换其左右孩子
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root==NULL)return root;
        queue<TreeNode*>qu;
        qu.push(root);
        while(!qu.empty()){
            for(int i=qu.size();i>0;i--){
                TreeNode*node=qu.front();
                qu.pop();
                swap(node->left,node->right);
                if(node->left)qu.push(node->left);
                if(node->right)qu.push(node->right);
            }
        }
        return root;
    }
};

以上的题目都是统一的套路，利用队列对二叉树进行层序遍历，对每一层进行相应的操作。