代码随想录day4——102二叉树的层序遍历/107Ⅱ/199.二叉树的右视图/429N叉树的层序遍历/515在每个树行中找最大值/116 填充每个节点的下一个右侧节点指针/117Ⅱ/104/111

102二叉树的层序遍历

题干

代码

• 队列实现

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*>que;
        if(root!=nullptr) que.push(root);
        vector<vector<int>> res;
        while(!que.empty()){
            vector<int> ans;
            //que.size()不能取代n，因为que会变化
            int n=que.size();
            for(int i=0;i<n;i++){
                //queue只有front() 没top()
                TreeNode*node=que.front();
                que.pop();
                ans.push_back(node->val);
                if(node->left)que.push(node->left);
                if(node->right)que.push(node->right);
            }
            res.push_back(ans);
        }
        return res;
    }
};

• 递归实现

class Solution {
public:
    //递归法
    void order(TreeNode*root,vector<vector<int>>& ans, int depth){
        if(root==nullptr)return;
        if(ans.size()==depth)
            ans.push_back(vector<int>());
        ans[depth].push_back(root->val);
        if(root->left)
            order(root->left,ans,depth+1);
        if(root->right)
            order(root->right,ans,depth+1);
    }
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        int depth=0;
        order(root,ans,depth);
        return ans;
    }
};

107二叉树的层次遍历 II

题干

在102的基础上将res向量反转一下即可

reverse(res.begin(),res.end());

199. 二叉树的右视图

题干199

代码

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

637.二叉树的层平均值

637题干

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode*>que;
        vector<double> ans;
        if(root!=nullptr) que.push(root);

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

429.N叉树的层序遍历

429题干

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        queue<Node*>que;
        vector<vector<int>> ans;
        if(root!=nullptr) que.push(root);

        while(!que.empty()){
            vector<int> tmp;
            int n=que.size();
            for(int i=0;i<n;i++){
                Node*node=que.front();
                que.pop();
                tmp.push_back(node->val);
                for(int j=0;j<node->children.size();j++){
                    if(node->children[j])que.push(node->children[j]);
                }
            }
            ans.push_back(tmp);
        }
        return ans;
    }
};

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

515题干

代码

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*>que;
        if(root!=nullptr)que.push(root);
        vector<int> ans;
        
        while(!que.empty()){
            int n=que.size();
            int max=que.front()->val;
            for(int i=0;i<n;i++){
                TreeNode* node=que.front();
                que.pop();
                if(node->val>max)max=node->val;
                if(node->left) que.push(node->left);
                if(node->right)que.push(node->right);
            }
            ans.push_back(max);
        }
        return ans;
    }
};

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

116题干

代码

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

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

力扣题目链接
117题干

代码

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

104.二叉树的最大深度

104题干

代码

• 递归实现

class Solution {
public:
    int maxDepth(TreeNode* root) 
    {
        //深度优先，用递归
        if(root==nullptr) return 0;
        return max(maxDepth(root->left),maxDepth(root->right))+1;
    }
};

• 队列套路实现

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

111题干

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