Leetcode 层序遍历

Leetcode 107 Binary Tree Level Order Traversal II  (bottom-up level order)

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*> que;
        if(root != NULL) que.push(root);
        vector<vector<int>> res;

        while(!que.empty()){
            int size = que.size();
            vector<int> oneLevelNode;
            for(int i=0; i<size; i++){
                TreeNode* curr = que.front();
                que.pop();
                oneLevelNode.push_back(curr->val);
                if(curr->left) que.push(curr->left);
                if(curr->right) que.push(curr->right);
            }

            res.insert(res.begin(), oneLevelNode);
        }

        return res;
    }
};

跟正常的层序遍历基本相同，使用queue存储之前的节点，存储完左右节点后pop

注意：

1. 在遍历一层的节点的时候， 要先固定size， 因为que.size是在变化的

2. 从下自上而下的方法：

1）可以直接使用reverse

2）使用vector.insert(position, val);

199 Binary Tree Right Side View

1.依旧层序遍历，但只保存每一层最右边的值

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        if(root != NULL) que.push(root);

        vector<int> res;

        while(!que.empty()){
            int size = que.size();
            for(int i=0; i<size; i++){
                TreeNode* curr = que.front();
                que.pop();
                if(curr->left) que.push(curr->left);
                if(curr->right) que.push(curr->right);
                if(i == size-1) res.push_back(curr->val);
            }
           
        }
        return res;
    }
};

2.迭代

level代表每一层的层数，如果找不到就会返回一直返回上一层找左右子叶，直到在需要的层数找到最右边的值

class Solution {
public:
    void helper(TreeNode* root, int level, vector<int> &res){
        if(root == NULL) return;

        if(res.size() == level) res.push_back(root->val);
        helper(root->right, level+1, res);
        helper(root->left, level+1, res);
    }
    vector<int> rightSideView(TreeNode* root) {
        if(!root) return {};
        vector<int> res;
        helper(root, 0, res);
        return res;
    }
};

637. Average of Levels in Binary Tree

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

        vector<double> res;

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

        return res;
    }
};

注意的问题：题目中要求average是一个double，所以sum也需要是double

515. Find Largest Value in Each Tree Row

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*> que;
        vector<int> res;
        if(root != NULL) que.push(root);

        while(!que.empty()){
            int size  = que.size();
            int maxVal = INT_MIN;
            for(int i=0; i<size; i++){
                TreeNode* curr = que.front();
                maxVal = (maxVal > curr->val)? maxVal:curr->val;
                que.pop();
                if(curr->left) que.push(curr->left);
                if(curr->right) que.push(curr->right);
            }
            res.push_back(maxVal);
        }

        return res;
    }
};

429. N-ary Tree Level Order Traversal

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

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

        while(!que.empty()){
            int size = que.size();
            vector<int> oneLevelNode;
            for(int i=0; i<size; i++){
                Node* curr = que.front();
                oneLevelNode.push_back(curr->val);
                que.pop();
                for(Node* child:curr->children){
                    que.push(child);
                }
            }

            res.push_back(oneLevelNode);
        }

        return res;
    }
};