【层序遍历专场练习Ⅱ】429. N叉树的层序遍历、515. 在每个树行中寻找最大值、116. 填充每个节点的下一个右侧节点指针、104二叉树的最大深度&559N叉树、11. 二叉树的最小深度
429. N叉树的层序遍历
题目描述：给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。
树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。
解答：思路与二叉树的层序遍历一致，主要在于子节点入队时稍有不同。N叉树判断子节点的是否为空（大小是否为0），非空时依次进行入队即可。其他操作与二叉树层序遍历一样。
代码实现：
class Solution {
public:
vector> levelOrder(Node* root) {
vector>result;
queueque;
if (root != NULL)
que.push(root);
while(!que.empty()){
vectorlayer;
int size = que.size();
for (int i = 0; ival);
que.pop();
if (p->children.size() != 0){//子节点入队
vectorch = p->children;
int size_Ch = ch.size();
for (int j = 0; j 515. 在每个树行中寻找最大值
题目描述：给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。
解答：依旧采用层序遍历，稍加修改，保存每一层的最大值即可。
代码实现：
class Solution {
public:
vector largestValues(TreeNode* root) {
queueque;
vectorresult;
if (root)
que.push(root);
while(!que.empty()){
int size = que.size();
int max = INT_MIN;
for (int i = 0; ival) max = p->val;
if (p->left) que.push(p->left);
if (p->right) que.push(p->right);
}
result.push_back(max);
}
return result;
}
}; 116. 填充每个节点的下一个右侧节点指针
题目描述：
给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：
struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
初始状态下，所有 next 指针都被设置为 NULL
解答：涉及到同一层的节点，考虑使用层序遍历。遇到非最右侧节点，令其next指向队列头的元素（即为同一层的下一个元素），遇到最右侧节点指向NULL即可。
代码实现：
class Solution {
public:
Node* connect(Node* root) {
queue que;
if (root)
que.push(root);
while(!que.empty()){
int size = que.size();
for (int i = 0; inext = NULL;
else{
p->next = que.front();
}
if (p->left) que.push(p->left);
if (p->right) que.push(p->right);
}
}
return root;
}
}; 104. 二叉树的最大深度
题目描述：给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
解答：
法一：采用层序遍历，每遍历一层后计数加1.
代码实现：
class Solution {
public:
int maxDepth(TreeNode* root) {
queueque;
if (root) que.push(root);
int num = 0;
while(!que.empty()){
num++;
int size = que.size();
for (int i = 0; ileft) que.push(p->left);
if (p->right) que.push(p->right);
}
}
return num;
}
}; 法二：采用递归法
class Solution {
public:
int maxDepth(TreeNode* root) {
if (root == NULL) return 0;
int num = max(maxDepth(root->left), maxDepth(root->right)) + 1;
return num;
}
};559. N 叉树的最大深度
题目描述：
给定一个 N 叉树，找到其最大深度。
最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。
N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔（请参见示例）。
解答：
法一：递归法
N叉树的最大深度和二叉树的最大深度类似，只是需要访问的子树数量变多了而已。
代码实现：
class Solution {
public:
int maxDepth(Node* root) {
if (root == 0) return 0;
int depth = 0;
for (int i = 0; i < root->children.size(); i++) {
depth = max (depth, maxDepth(root->children[i]));
}
return depth+1;
}
};法二：迭代解法
层序遍历最为合适，采用层序遍历。
代码实现：
class Solution {
public:
int maxDepth(Node* root) {
if (root == 0) return 0;
queueque;
que.push(root);
int depth = 0;
while(!que.empty()){
int size = que.size();
depth++;
for (int i =0; ichildren;
children = p->children;
for(int j = 0; j 111. 二叉树的最小深度
题目描述：给定一个二叉树，找出其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。
解答：
法一：
采用层序遍历，计算层的深度，当遇到左右子节点均为空时，即找到最小深度，返回结果。
代码实现：
class Solution {
public:
int minDepth(TreeNode* root) {
queueque;
if (root) que.push(root);
int num = 0;
while(!que.empty()){
num++;
int size = que.size();
for (int i = 0; ileft) que.push(p->left);
if (p->right) que.push(p->right);
if (! p->left && ! p->right) return num;
}
}
return num;
}
}; 法二：
采用递归法，左右中的遍历处理方式。需要注意的是在遇到节点左孩子为空右孩子不为空，或者左孩子不为空右孩子为空的情况要特殊处理，此时并不是最小高度。左空右非空时返回其右子树的最小高度，左非空右空返回其左子树的最小高度。
代码实现：
class Solution {
public:
int minDepth(TreeNode* root) {
if(root == NULL) return 0;
int left = minDepth(root->left);
int right = minDepth(root->right);
// 当一个左子树为空，右不为空，这时并不是最低点
if (root->left == NULL && root->right != NULL) {
return 1 + right;
}
// 当一个右子树为空，左不为空，这时并不是最低点
if (root->left != NULL && root->right == NULL) {
return 1 + left;
}
int num = min(left,right) + 1;
return num;
}
};