LeetCode---二叉树的广度优先遍历相关

广度优先遍历

直白一点，广度优先遍历指的是按照二叉树层级的思想，从左到右一层一层的遍历；
首先，完成这种遍历思想需要借助一个辅助的数据结构队列来完成；
队列先进先出，符合一层一层遍历的逻辑，而是用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。
废话不多说，上例题：

LeetCode102

题目描述：
给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。
示例：
二叉树：[3,9,20,null,null,15,7],

返回其层次遍历结果：
[[3],[9,20], [15,7]]。

代码解答：

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        queue<TreeNode*> que;
        if(root!=NULL)
            que.push(root);
        while(!que.empty())
        {
            vector<int> vec;   //用来存放节点的数值；
            int size=que.size();
            for(int i=0;i<size;i++)
            {
                TreeNode* node=que.front();    //保存que的头结点
                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;
    }
};

对于此份代码，如果理解吃透，则可以成为一份解决广度优先遍历的模版代码，非常好使；

LeetCode107 二叉树的层次遍历 II

给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

例如：
给定二叉树 [3,9,20,null,null,15,7],

返回其自底向上的层次遍历为：
[ [15,7], [9,20], [3]]

思路分析：
只不过是上面代码的小改动而已；
代码：

class Solution {
public:
        vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> result;
        queue<TreeNode*> que;
        if(root!=NULL) que.push(root);
        while(!que.empty())
        {
            vector<int> vec;
            int 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);
        }
        reverse(result.begin(),result.end());     //利用库函数逆置二维数组；
        return result;
    }
};

LeetCode199 二叉树的右视图

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

示例:
输入: [1,2,3,null,5,null,4]
输出: [1, 3, 4]
解释:

1 <—
/
2 3 <—
\
5 4 <—
思路分析：
很好想。只要最右侧的节点的数值，只需要在层序遍历的时候，判断这个节点是否是最右侧的节点，如果是，将此节点记录下来。
代码：

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        //思路：在层序遍历的时候，找到最后一个数字，添加到vec中，最终返回vec；    此处的方法是广度优先遍历
        vector<int> result;
        queue<TreeNode*> que;
        if(root!=NULL) 
        {
            que.push(root);
            //result.push_back(root->val);
        }
        while(!que.empty())
        {
            int size=que.size();
            for(int i=0;i<size;i++)
            {
                TreeNode* node=que.front();
                que.pop();
                if(i==(size-1))
                {
                   result.push_back(node->val); 
                }
                if(node->left)   que.push(node->left);
                if(node->right)  que.push(node->right);
            }
        }
        return result;
    }
};

Leetcode637 二叉树的层平均值

题目描述：
给定一个非空二叉树, 返回一个由每层节点平均值组成的数组。
示例 1：

输入：
3
9 20
15 7
输出：[3, 14.5, 11]

思路分析：
依旧是上面代码的小改动而已：多一个记录每层的数据和sum，然后输出每层的平均值；
代码：

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 sum=0;        //注意最后的平均值可能是double类型的，这里不能把sum定义成int
            for(int i=0;i<size;i++)
            {
                TreeNode* node=que.front();
                que.pop();
                sum=sum+node->val;
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            result.push_back((sum/size));
        }
        return result;
    }
};

LeetCode429 N叉树的层序遍历

注意，这道题的节点定义和之前有所不同：
节点定义：

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

解题思路：
和上述套路相同，只不过在添加到队列的时候，添加N个孩子进入队列，而不是二叉树的左右两个孩子。
代码：

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

            }
            result.push_back(vec);
       }
       return result;
    }
};

LeetCode 226 翻转二叉树

注意，此处可以借用层序遍历非递归实现翻转一颗二叉树；
思路分析：
翻转一颗二叉树，只需要遍历每一个节点的时候，交换每一个节点的左右两个孩子节点，即可实现整棵树的逆置。
代码：

        TreeNode* invertTree(TreeNode* root) {
            queue<TreeNode*> que;              //层序遍历需要借助队列
            if(root!=NULL)  que.push(root);
            while(!que.empty())
            {
                int size=que.size();
                for(int i=0;i<size;i++)
                {
                    TreeNode* node=que.front();
                    que.pop();
                    //只要在遍历每个节点的时候，交换子节点的左右位置即可；
                    swap(node->left,node->right);
                    if(node->left) que.push(node->left);                //因为是队列，所以先左再右
                    if(node->right) que.push(node->right);
                }
            }
            return root;
        }

总结

看透一道题，能打六道题！