记录D12&13-23.5.31&6.1

原创已于 2023-06-19 11:37:48 修改 · 76 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #算法

于 2023-05-31 22:22:13 首次发布

文章介绍了如何使用层序遍历解决一系列LeetCode上的二叉树问题，包括标准的层序遍历、从下往上、右视图、层平均值以及寻找最大值等，同时也展示了如何将这种方法扩展到N叉树的情况。

二叉树的层序遍历

LC102 二叉树的层序遍历

层序遍历的话，就类似广度优先搜索，可以用队列的思想，主要是要用size来控制每一层的处理次数。

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        queue<TreeNode*> que;
        if(root==NULL) return ans;
        que.push(root);
        while(!que.empty()){
            int size=que.size();
            vector<int> temp;
            while(size--){
                TreeNode* cur=que.front();
                temp.push_back(cur->val);
                if(cur->left) que.push(cur->left);
                if(cur->right) que.push(cur->right);
                que.pop();
            }
            ans.push_back(temp);
        }
        return ans;
    }
};

LC107 二叉树的层序遍历2

就是在上一题的基础上对ans进行反转。

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> ans;
        queue<TreeNode*> que;
        if(root==NULL) return ans;
        que.push(root);
        while(!que.empty()){
            int size=que.size();
            vector<int> temp;
            while(size--){
                TreeNode* cur=que.front();
                que.pop();
                temp.push_back(cur->val);
                if(cur->left) que.push(cur->left);
                if(cur->right) que.push(cur->right);
            }
            ans.push_back(temp);
        }
        reverse(ans.begin(),ans.end());
        return ans;
    }
};

LC199 二叉树的右视图

之前用vector来记录每一行的元素，现在只用一个int来记录每一行的最后一个元素就好了。

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> ans;
        queue<TreeNode*> que;
        if(root==NULL) return ans;
        que.push(root);
        while(!que.empty()){
            int size=que.size();
            int temp;
            while(size--){
                TreeNode* cur=que.front();
                que.pop();
                temp=cur->val;
                if(cur->left) que.push(cur->left);
                if(cur->right) que.push(cur->right);
            }
            ans.push_back(temp);
        }
        return ans;
    }
};

LC637 二叉树的层平均值

这道题也是个easy。只需要用一个double类型的变量来累加每一层的元素，最后除以这一层的元素数量就好了。

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> ans;
        queue<TreeNode*> que;
        if(root==NULL) return ans;
        que.push(root);
        while(!que.empty()){
            int size=que.size();
            double num=size;
            double temp=0;
            while(size--){
                TreeNode* cur=que.front();
                que.pop();
                temp+=cur->val;
                if(cur->left) que.push(cur->left);
                if(cur->right) que.push(cur->right);
            }
            ans.push_back(temp/num);
        }
        return ans;
    }
};

LC429 N叉树的层序遍历

基本和二叉树的方法是一样的，只要是对N叉树不太熟悉。children不是多个属性，是一个由vector构成的单个属性。所以应该是用children.size()来控制数量。

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

LC515 在每个树行中找最大值

只能说爽，学会了层序遍历的模板后，所有的问题都可以用一套算法来通关。
这道题的唯一需要注意的点就是val的范围是-INT到INT，所以一开始的初始值应该设置为INT_MIN。
如果这道题改为找最小值，那么就把初始值改为INT_MAX就好了。

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        vector<int> ans;
        queue<TreeNode*> que;
        if(root == NULL) return ans;
        que.push(root);
        while(!que.empty()){
            int temp=INT_MIN;
            int size=que.size();
            while(size--){
                TreeNode* cur = que.front();
                que.pop();
                temp=max(temp,cur->val);
                if(cur->left) que.push(cur->left);
                if(cur->right) que.push(cur->right);
            }
            ans.push_back(temp);
        }
        return ans;
    }
};

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

中间的处理过程有点像链表。反正也是前后节点的链接。一开始是打算把每一行的最后一个节点单独处理，但后来发现比较麻烦，因为最后一个节点也是要把左右子节点载入的。所以最后看了一下题解，发现单独处理第一个节点会比较方便。

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

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

和上一题一模一样，代码都不需要改，自己重新写一遍就当作加深印象了。

LC104 二叉树的最大深度

一样都是用层序遍历的模版，设定一个depth的值，每一层+1，最后输出结果。

class Solution {
public:
    int maxDepth(TreeNode* root) {
        int ans=0;
        if(root == NULL) return 0;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
            int size=que.size();
            ans++;
            while(size--){
                TreeNode* cur=que.front();
                que.pop();
                if(cur->left) que.push(cur->left);
                if(cur->right) que.push(cur->right);
            }
        }
        return ans;
    }
};

LC111 二叉树的最小深度

这道题也非常简单，就是在模板的基础上设置终止条件。当一个子节点没有左右节点时，那就是这棵树的最小深度所在的层。

class Solution {
public:
    int minDepth(TreeNode* root) {
        int depth=0;
        queue<TreeNode*> que;
        if(root==NULL) return 0;
        que.push(root);
        while(!que.empty()){
            int size=que.size();
            depth++;
            while(size--){
                TreeNode* cur=que.front();
                que.pop();
                if(cur->left) que.push(cur->left);
                if(cur->right) que.push(cur->right);
                if(cur->left==NULL && cur->right==NULL) return depth;
            }
        }
        return depth;
    }
};