算法day12| 102.层序遍历、107层序遍历2、199.二叉树的右视图、637.二叉树的层平均值

102.层序遍历

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

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

提示：

• 树中节点数目在范围 [0, 2000] 内

• -1000 <= Node.val <= 1000

  ---

  难度不小，代码如下：

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

总体思路：

• 分层：利用size = que.size()，size是多少，就一次性处理多少个结点，一次性处理的结点就放入一层中。
• **处理：**对于一个结点，处理分为两个部分：
  1. 弹出该节点并存储到数组中
  2. 将自己的孩子结点入栈

分层和单个结点的处理是紧密相关的。

另外，一些代码细节：

1. 根节点在入队前要先判断是否为空
2. 求二位数组时，可以先设置一个一维数组
3. vector.push_back是动态插入的

107层序遍历2

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

199.二叉树的右视图

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

其实就是层序遍历的变式，其他地方基本不变，唯一改变的地方就是“处理”操作：队列只是起到一个存储访问过的元素的功能，而队列里面只有一部分符合要求的元素是需要放在result数组里面的，并不是队列里面所有的元素都会放在result数组里面！

另外，不要害怕有看似多余的代码。对于时间复杂度的计算，是看while、for等循环的，而不是代码的长短。只要循环控制好了，代码再长其实也无所谓。

637.二叉树的层平均值

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