二叉树的广度优先遍历
广度优先遍历,又称层序遍历,逐层遍历二叉树,在每一层中,从左至右依次遍历各个结点。层序遍历需要借助一个数据结构,存储当前层内所有元素节点的信息。
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
queue<TreeNode*> que;
if (root != nullptr) que.push(root);
vector<vector<int>> result;
while (!que.empty()) {
int size = que.size();
vector<int> vec;
while (size--) {
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);
}
return result;
}
};
class Solution { // 递归法
public:
void order(TreeNode* cur, vector<vector<int>>& result, int depth) {
if (cur == nullptr) return ;
if (depth == result.size()) result.push_back(vector<int>());
result[depth].push_back(cur->val);
order(cur->left, result, depth + 1);
order(cur->right, result, depth + 1);
}
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> result;
int depth = 0;
order(root, result, depth);
return result;
}
};
层序遍历也可以递归实现,但是迭代实现的层序遍历可以解决很多问题,可以作为二叉树层序遍历的通解,比如力扣的102、107、199、637、429、515、116、117、104和111。在此给出上述题的代码:
107.二叉树的层序遍历Ⅱ
class Solution {
public:
vector<vector<int>> levelOrderBottom(TreeNode* root) {
queue<TreeNode*> que;
if (root != nullptr) que.push(root);
vector<vector<int>> result;
while (!que.empty()) {
int size = que.size();
vector<int> vec;
while (size--) {
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;
}
};
199.二叉树的右视图
class Solution {
public:
vector<int> rightSideView(TreeNode* root) {
queue<TreeNode*> que;
if (root != nullptr) que.push(root);
vector<int> result;
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;
}
};
637.二叉树的层平均值
class Solution {
public:
vector<double> averageOfLevels(TreeNode* root) {
queue<TreeNode*> que;
vector<double> result;
if (root != nullptr) que.push(root);
while (!que.empty()) {
int size = que.size();
double count = 0;
for (int i = 0; i < size; i++) {
TreeNode* node = que.front();
que.pop();
count += node->val;
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
double num = count / size;
result.push_back(num);
}
return result;
}
};
429.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;
}
};
class Solution {
public:
vector<vector<int>> levelOrder(Node* root) {
queue<Node*> que;
if (root != nullptr) que.push(root);
vector<vector<int>> result;
while (!que.empty()) {
int size = que.size();
vector<int> vec;
while (size--) {
Node* node = que.front();
que.pop();
vec.push_back(node->val);
for (int i = 0; i < node->children.size(); i++) {
que.push(node->children[i]);
}
}
result.push_back(vec);
}
return result;
}
};
515.在每个树行中找最大值
class Solution {
public:
vector<int> largestValues(TreeNode* root) {
queue<TreeNode*> que;
if (root != nullptr) que.push(root);
vector<int> result;
while (!que.empty()) {
int size = que.size();
int max = que.front()->val;
while (size--) {
TreeNode* node = que.front();
que.pop();
if (node->val > max) max = node->val;
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
result.push_back(max);
}
return result;
}
};
116.填充每个节点的下一个右侧节点指针、117.填充每个节点的下一个右侧节点指针Ⅱ
class Node {
public:
int val;
Node* left;
Node* right;
Node* next;
Node() : val(0), left(NULL), right(NULL), next(NULL) {}
Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}
Node(int _val, Node* _left, Node* _right, Node* _next)
: val(_val), left(_left), right(_right), next(_next) {}
};
class Solution {
public:
Node* connect(Node* root) {
queue<Node*> que;
if (root != nullptr) que.push(root);
while (!que.empty()) {
int size = que.size();
for (int i = 0; i < size; i++) {
Node* node = que.front();
que.pop();
node->next = que.front();
if (i == size - 1) node->next = nullptr;
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
}
return root;
}
};
104.二叉树的最大深度
class Solution {
public:
int maxDepth(TreeNode* root) {
queue<TreeNode*> que;
int layer = 0;
if (root != nullptr) que.push(root);
while (!que.empty()) {
int size = que.size();
while (size--) {
TreeNode* node = que.front();
que.pop();
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
++layer;
}
return layer;
}
}
111.二叉树的最小深度
class Solution {
public:
int minDepth(TreeNode* root) {
queue<TreeNode*> que;
int layer = 0;
if (root != nullptr) que.push(root);
while (!que.empty()) {
int size = que.size();
while (size--) {
TreeNode* node = que.front();
que.pop();
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
if (!node->left && !node->right) return ++layer;
}
++layer;
}
return layer;
}
};
226. 翻转二叉树
交换二叉树左右子树对应位置的节点,即完成翻转。可以通过深度优先所搜的递归法和迭代法完成,也可以通过层序遍历完成。
class Solution { // 广度优先遍历
public:
TreeNode* invertTree(TreeNode* root) {
queue<TreeNode*> que;
if (root != nullptr) que.push(root);
while (!que.empty()) {
int size = que.size();
while (size--) {
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;
}
};
class Solution { // 深度优先遍历,前序递归法
public:
TreeNode* invertTree(TreeNode* root) {
if (root == nullptr) return root;
swap(root->left, root->right);
invertTree(root->left);
invertTree(root->right);
return root;
}
};
class Solution { //深度优先遍历,前序迭代法
public:
TreeNode* invertTree(TreeNode* root) {
if (root == nullptr) return root;
stack<TreeNode*> st;
st.push(root);
while(!st.empty()) {
TreeNode* node = st.top();
st.pop();
swap(node->left, node->right);
if(node->right) st.push(node->right);
if(node->left) st.push(node->left);
}
return root;
}
};
101.对称二叉树
对称二叉树,左右子树对应位置上的节点相同,包括位置相同和值相同。
class Solution { // 递归法
public:
bool compare(TreeNode* left, TreeNode* right) {
if (left == nullptr && right != nullptr) return false;
else if (left != nullptr && right == nullptr) return false;
else if (left == nullptr && right == nullptr) return true;
else if (left->val != right->val) return false;
bool outsize = compare(left->left, right->right);
bool inside = compare(left->right, right->left);
return outsize && inside;
}
bool isSymmetric(TreeNode* root) {
if (root == nullptr) return true;
return compare(root->left, root->right);
}
};
可以通过深度优先搜索的迭代法和递归法实现,在此仅给出相对简单的递归法,笔者尝试过层序遍历的方法,但是无法判断对应位置上的节点是否相同,只能判断左右子树的值相同,大家可以试试层序遍历的实现方法。