429. N叉树的层序遍历
题目描述:给定一个 N 叉树,返回其节点值的层序遍历。(即从左到右,逐层遍历)。
树的序列化输入是用层序遍历,每组子节点都由 null 值分隔(参见示例)。
解答:思路与二叉树的层序遍历一致,主要在于子节点入队时稍有不同。N叉树判断子节点的是否为空(大小是否为0),非空时依次进行入队即可。其他操作与二叉树层序遍历一样。
代码实现:
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()){
vector<int>layer;
int size = que.size();
for (int i = 0; i<size; i++){
Node* p = que.front();
layer.push_back(p->val);
que.pop();
if (p->children.size() != 0){//子节点入队
vector<Node*>ch = p->children;
int size_Ch = ch.size();
for (int j = 0; j<size_Ch; j++)
que.push(ch[j]);
}
}
result.push_back(layer);
}
return result;
}
};
515. 在每个树行中寻找最大值
题目描述:给定一棵二叉树的根节点 root
,请找出该二叉树中每一层的最大值。
解答:依旧采用层序遍历,稍加修改,保存每一层的最大值即可。
代码实现:
class Solution {
public:
vector<int> largestValues(TreeNode* root) {
queue<TreeNode*>que;
vector<int>result;
if (root)
que.push(root);
while(!que.empty()){
int size = que.size();
int max = INT_MIN;
for (int i = 0; i<size; i++){
TreeNode* p = que.front();
que.pop();
if (max < p->val) 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<Node*> que;
if (root)
que.push(root);
while(!que.empty()){
int size = que.size();
for (int i = 0; i<size; i++){
Node* p = que.front();
que.pop();
if (i == size-1)
p->next = 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) {
queue<TreeNode*>que;
if (root) que.push(root);
int num = 0;
while(!que.empty()){
num++;
int size = que.size();
for (int i = 0; i<size; i++){
TreeNode* p = que.front();
que.pop();
if (p->left) 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;
queue<Node*>que;
que.push(root);
int depth = 0;
while(!que.empty()){
int size = que.size();
depth++;
for (int i =0; i<size; i++){
Node* p = que.front();
que.pop();
vector<Node*>children;
children = p->children;
for(int j = 0; j<children.size(); j++)
que.push(children[j]);
}
}
return depth;
}
};
111. 二叉树的最小深度
题目描述:给定一个二叉树,找出其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明:叶子节点是指没有子节点的节点。
解答:
法一:
采用层序遍历,计算层的深度,当遇到左右子节点均为空时,即找到最小深度,返回结果。
代码实现:
class Solution {
public:
int minDepth(TreeNode* root) {
queue<TreeNode*>que;
if (root) que.push(root);
int num = 0;
while(!que.empty()){
num++;
int size = que.size();
for (int i = 0; i<size; i++){
TreeNode* p = que.front();
que.pop();
if (p->left) 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;
}
};