二叉树的层序遍历BFS力扣102题，103题，104题，107题

层次遍历需要利用到队列，队列是先进先出的线性表，c++自带的队列在queue头文件里。

力扣第102题

我这里先给出力扣第102题的题目和答案,我代码的注释写的很清楚
给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

示例：
二叉树：[3,9,20,null,null,15,7],
3
/ \
9 20
/ \
15 7
返回其层序遍历结果：
[
[3],
[9,20],
[15,7]
]
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
 
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> solve;//用来返回最后的结果
	if (!root)//如果root为空则直接返回solve
	{
		return solve;
	}
	
	queue<TreeNode*> q;//定义队列
	q.push(root);//插入根节点
	while (!q.empty())//当队列为空时结束循环
	{
		int size = q.size();//由于q.size()会在添加元素时改变所以要先用size储存。
		
		vector<int> temp;//用于储存这一层的值
		for (int i = 0; i < size; i++)//添加队列中的每个元素的左右枝
		{
			TreeNode* node=q.front();//node为此时队列中第一个元素
			temp.push_back(node->val);//储存此时的node节点
			if (node->left)//如果左枝不为空则添加进队列
			{
				q.push(node->left);
			}
			if (node->right)
			{
				q.push(node->right);
			}
			
			q.pop();//删除此时队列第一个元素
		}
		solve.push_back(temp);讲这一层的结果插入最终结果
	}
	return solve;
    }
};

队列的运动轨迹（由于时本人自己做的图片所以有点反人类）

力扣第102题

给定一个二叉树，返回其节点值的锯齿形层序遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

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

返回锯齿形层序遍历如下：

[
[3],
[20,9],
[15,7]
]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-tree-zigzag-level-order-traversal

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
vector<vector<int>> solve;
	if (!root)
	{
		return solve;
	}
	int o=0;
	queue<TreeNode*> q;
	q.push(root);
	while (!q.empty())
	{
		int size = q.size();
		vector<int> temp;
        o++;
		for (int i = 0; i < size; i++)
		{
			TreeNode* node=q.front();
			
				if (node->left)
				{
					q.push(node->left);
				}
				if (node->right)
				{
					q.push(node->right);
				}
			
			

			temp.push_back(node->val);
			q.pop();
		}
        if (o%2==0)
		{
			reverse(temp.begin(), temp.end());
		}
		solve.push_back(temp);
	}
	return solve;
    }
};

在102题的基础上，如果时奇数行temp数组不变，而偶数行则将temp数组反转就可以了

力扣第104题

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：
给定二叉树 [3,9,20,null,null,15,7]，
3
/
9 20
/
15 7
返回它的最大深度 3 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-depth-of-binary-tree

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode* root) {
	if (!root)
	{
		return 0;
	}
	
	queue<TreeNode*> q;
	q.push(root);
    int solve=0;
	while (!q.empty())
	{
		int size = q.size();

		for (int i = 0; i < size; i++)
		{
			TreeNode* node=q.front();
			if (node->left)
			{
				q.push(node->left);
			}
			if (node->right)
			{
				q.push(node->right);
			}
			
			q.pop();
		}
     solve++;
	}
	return solve;
    }
};

原来还要定义一个二维数组现在连数组都不要了，在遍历完一层加个1就好了。

力扣第107题

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

例如：
给定二叉树 [3,9,20,null,null,15,7],
3
/
9 20
/
15 7
返回其自底向上的层序遍历为：

[
[15,7],
[9,20],
[3]
]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal-ii

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
vector<vector<int>> solve;
	if (!root)
	{
		return solve;
	}
	
	queue<TreeNode*> q;
    q.push(root);
	while (!q.empty())
	{
	
		vector<int> temp;
		int size = q.size();
		for (int i = 0; i < size; i++)
		{	
            TreeNode* node=q.front();
			temp.push_back(node->val);
			if (node->left)
			{
				q.push(node->left);
			
			}
			if (node->right)
			{
				q.push(node->right);

			}
			q.pop();
		}
		solve.push_back(temp);
		
	}
	reverse(solve.begin(), solve.end());
	return solve;
    }
};

在原来的102题的基础上反转最后的solve数组就可以了，只要添加一行代码就可以了。