【层序遍历专场练习Ⅰ】102. 二叉树的层序遍历、107. 二叉树的层次遍历Ⅱ、199. 二叉树的右视图、637. 二叉树的平均值

102. 二叉树的层序遍历

题目描述：给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）

解答：

遍历很简单，出队进行访问，访问结束后，左右节点分别入队。

但是有个问题，每一层访问多少个节点？

其实每次队中的元素即为这一层的所有元素，每次获取一下队列长度再进行遍历即可。此处容易写出BUG的点在于：使用固定大小size，不要使用que.size()，因为que.size是不断变化的。

代码实现：

class Solution {
public:
    vector<vector<int>> levelOrder(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;
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.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;
    }
};

107. 二叉树的层次遍历Ⅱ

题目描述：给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

解答：先按照上题进行层序遍历，先不写入结果中，记录每一层的节点数量，将所有节点的值存在一个数组中。然后按照每层的节点数从后往前遍历存储节点值的数组，反转后放入resutl。

代码实现：

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<int>layer, num;
        vector<vector<int>>result;
        queue<TreeNode*>que;
        if(root != NULL)
            que.push(root);
        while(!que.empty()){
            int size = que.size();
            num.push_back(size);//记录每一层的节点数量
            for (int i=0; i<size; i++){
                TreeNode* p = que.front();
                layer.push_back(p->val);//用一个数组存储按序所有节点值
                que.pop();
                if (p->left) que.push(p->left);
                if (p->right) que.push(p->right); 
            }
        }
        //从后往前遍历，将每一层的遍历结果存入result
        for (int i=num.size()-1, j=layer.size()-1; i>=0 ;i--){
            int len = num[i];
            vector<int>st;
            while(len){
                st.push_back(layer[j--]);
                len--;
            }
            reverse(st.begin(), st.end());//因为从左向右遍历，翻转
            result.push_back(st);
        }
        return result;
    }
};

199. 二叉树的右视图

题目描述：给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

解答：

        首先这道题目提到每一层的最右侧，想到应该采用层次遍历。

        其次考虑什么时候是那一侧的最右侧？

        在进行层次遍历时每一层的数量是知道的，在访问至这一层的最后一个元素时，其即为最右侧的元素（因为是从左至右遍历）。所以只需要修改层次遍历代码，在每一层访问至最后一个元素时存储到结果中即可。

代码实现：

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int>result;
        queue<TreeNode*>que;
        if (root != NULL)
            que.push(root);
        while(!que.empty()){
            int size = que.size();
            for (int i = 0; i<size; i++){
                TreeNode* p = que.front();
                que.pop();
                if (i == size-1)    result.push_back(p->val);//只存储最右侧元素即可
                if (p->left)    que.push(p->left);
                if (p->right)   que.push(p->right);
            }
        }
        return result;
    }
};

637. 二叉树的平均值

题目描述：给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

解答：思路很简单，层次遍历，遍历完一层后计算均值即可。

代码实现：

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double>result;
        queue<TreeNode*>que;
        if (root != NULL)
            que.push(root);
        while(!que.empty()){
            int size = que.size();
            double num = 0;
            for (int i = 0; i<size; i++){
                TreeNode* p = que.front();
                que.pop();
                num += p->val;
                if (i == size-1)    result.push_back(num/size);//一层遍历完后计算均值
                if (p->left)    que.push(p->left);
                if (p->right)   que.push(p->right);
            }
        }
        return result;
    }
};