目录
102. 二叉树的层序遍历
这里要用双端队列,queue,队列里面的值类型是TreeNode*,queue的用法见第十天,这里用while比for好像快一点
/**
* 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) {
queue<TreeNode*> que;
vector<vector<int>> res;
if (root != nullptr){
que.push(root);
}
while (!que.empty()){
int cnt = que.size();
vector<int> vtmp;
while (cnt--){
TreeNode* tmp = que.front();
vtmp.push_back(tmp->val);
que.pop();
if (tmp->left != nullptr) que.push(tmp->left);
if (tmp->right != nullptr) que.push(tmp->right);
}
res.push_back(vtmp);
}
return res;
}
};
107. 二叉树的层序遍历 II
最后一步reverse即可得到自底向上的层序遍历
/**
* 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>> res;
queue<TreeNode*> que;
if (root != nullptr){
que.push(root);
}
while (!que.empty()){
int cnt = que.size();
vector<int> vec;
while (cnt--){
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);
}
res.push_back(vec);
}
reverse(res.begin(), res.end());
return res;
}
};
199. 二叉树的右视图
其实是层序遍历每层的最后一个值
/**
* 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<int> rightSideView(TreeNode* root) {
vector<int> res;
queue<TreeNode*> que;
if (root != nullptr){
que.push(root);
}
while (!que.empty()){
int cnt = que.size();
while (cnt--){
TreeNode* node = que.front();
que.pop();
if (cnt == 0) res.push_back(node->val);
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
}
return res;
}
};
637. 二叉树的层平均值
层序的基础上求平均值
/**
* 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<double> averageOfLevels(TreeNode* root) {
vector<double> res;
queue<TreeNode*> que;
if (root != nullptr){
que.push(root);
}
while (!que.empty()){
double tmp = 0.0;
int cnt = que.size();
double div = cnt;
while (cnt--){
TreeNode* node = que.front();
que.pop();
tmp += node->val;
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
res.push_back(tmp/div);
}
return res;
}
};
429. N 叉树的层序遍历
重点在追加N叉树的孩子的时候,需要一个循环
/*
// Definition for a Node.
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) {
vector<vector<int>> res;
queue<Node*> que;
if (root != nullptr){
que.push(root);
}
while (!que.empty()){
int cnt = que.size();
vector<int> tmp;
while (cnt--){
Node* node = que.front();
que.pop();
tmp.push_back(node->val);
for(int i = 0; i < node->children.size(); i++){
que.push(node->children[i]);
}
}
res.push_back(tmp);
}
return res;
}
};
515. 在每个树行中找最大值
每次循环的时候保留最大值即可,不需要再构建一个vector
/**
* 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<int> largestValues(TreeNode* root) {
vector<int> res;
queue<TreeNode*> que;
if (root != nullptr){
que.push(root);
}
while (!que.empty()){
int cnt = que.size();
int tmp = que.front()->val;
while (cnt--){
TreeNode* node = que.front();
que.pop();
tmp = (tmp < node->val) ? node->val : tmp;
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
res.push_back(tmp);
}
return res;
}
};
116. 填充每个节点的下一个右侧节点指针
每一级的最后一个节点指向NULL,其他节点指向队列的front即可
直接在原Node上进行操作,不需要额外构建数据结构
/*
// Definition for a Node.
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 != NULL){
que.push(root);
}
while (!que.empty()){
int cnt = que.size();
while(cnt--){
Node* node = que.front();
que.pop();
if (cnt == 0){
node->next = NULL;
}
else{
node->next = que.front();
}
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
}
return root;
}
};
117. 填充每个节点的下一个右侧节点指针 II
代码和上一题一毛一样,我就不贴了,是不是完美二叉树并不会对解决这个问题造成任何干扰
104. 二叉树的最大深度
其实这道题用深搜应该更好,不过这里先用广搜吧,总有用深搜的时候
/**
* 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) {
int depth = 0;
queue<TreeNode*> que;
if (root != nullptr){
que.push(root);
}
while (!que.empty()){
int cnt = que.size();
depth++;
while (cnt--){
TreeNode* node = que.front();
que.pop();
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
}
return depth;
}
};
111. 二叉树的最小深度
当左右孩子都为空的时候,说明遇到了最小深度的层,可以直接return,不过要注意,最后返回的时候需要一个return
/**
* 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 minDepth(TreeNode* root) {
int min_cnt = 0;
queue<TreeNode*> que;
if (root != nullptr){
que.push(root);
}
while (!que.empty()){
int cnt = que.size();
min_cnt++;
while(cnt--){
TreeNode* node = que.front();
que.pop();
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
if (!node->left and !node->right) return min_cnt;
}
}
return min_cnt;
}
};
226. 翻转二叉树
在遍历的时间交换两个子节点即可
/**
* 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:
TreeNode* invertTree(TreeNode* root) {
queue<TreeNode*> que;
if (root != nullptr){
que.push(root);
}
while (!que.empty()){
int cnt = que.size();
while (cnt--){
TreeNode* node= que.front();
que.pop();
TreeNode* tmp = node->left;
node->left = node->right;
node->right = tmp;
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
}
return root;
}
};
//递归
class Solution {
public:
void rever(TreeNode* cur){
if (cur == nullptr){
return;
}
TreeNode* tmp = cur->left;
cur->left = cur->right;
cur->right = tmp;
if (cur->left) rever(cur->left);
if (cur->right) rever(cur->right);
}
TreeNode* invertTree(TreeNode* root) {
rever(root);
return root;
}
};
//这里是迭代法,统一迭代还要学习一下
class Solution {
public:
TreeNode* invertTree(TreeNode* root) {
stack<TreeNode*> st;
if (root != nullptr){
st.push(root);
}
while (!st.empty()){
TreeNode* node = st.top();
st.pop();
swap(node->left, node->right);
if (node->right != nullptr){
st.push(node->right);
}
if (node->left != nullptr){
st.push(node->left);
}
}
return root;
}
};
101. 对称二叉树
判断两个子二叉树是否可以翻转
/**
* 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:
bool isSymmetric(TreeNode* root) {
if (root == nullptr)
return true;
queue<TreeNode*> que;
que.push(root->left);
que.push(root->right);
while (!que.empty()){
TreeNode* left = que.front();
que.pop();
TreeNode* right = que.front();
que.pop();
if (!left && !right) //左右为空,则彼此堆成
continue;
if (!left || !right || (left->val != right->val)) //左右有一不为空,或值不等
return false;
que.push(left->left);
que.push(right->right);
que.push(left->right);
que.push(right->left);
}
return true;
}
};