层序遍历
题目链接(102):https://leetcode.cn/problems/binary-tree-level-order-traversal/comments/
代码:
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
queue<TreeNode*> que;
vector<vector<int>> result;
if(root == nullptr)
return result;
que.push(root);
while(!que.empty())
{
int size = que.size();
vector<int> tmp;
TreeNode* dp;
for(int i = 0; i < size; i ++)
{
dp = que.front();
que.pop();
tmp.push_back(dp->val);
if(dp->left)
que.push(dp->left);
if(dp->right)
que.push(dp->right);
}
result.push_back(tmp);
}
return result;
}
};
递归法
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> result;
order(root,0,result);
return result;
}
void order(TreeNode* root,int deep,vector<vector<int>>& result)
{
if(root == nullptr)
return;
if(deep == result.size())
result.push_back(vector<int>{});
result[deep].push_back(root->val);
order(root->left,deep+1,result);
order(root->right,deep+1,result);
}
};
递归法其实不难,但是我一看到这种写法就害怕,其实可以慢慢来
题目链接(107):https://leetcode.cn/problems/binary-tree-level-order-traversal-ii/
代码:
class Solution {
public:
vector<vector<int>> levelOrderBottom(TreeNode* root) {
vector<vector<int>> result;
if(root == 0)
return result;
queue<TreeNode*> que;
que.push(root);
while(!que.empty())
{
int size = que.size();
vector<int> tmp;
TreeNode* dp;
for(int i = 0; i < size; i ++)
{
dp = que.front();
que.pop();
tmp.push_back(dp->val);
if(dp->left)
que.push(dp->left);
if(dp->right)
que.push(dp->right);
}
result.push_back(tmp);
}
reverse(result.begin(),result.end());
return result;
}
};
和102一样的,就是最后颠倒了下顺序
题目链接(199):https://leetcode.cn/problems/binary-tree-right-side-view/submissions/
代码:
class Solution {
public:
vector<int> rightSideView(TreeNode* root) {
vector<int> result;
if(root == 0)
return result;
queue<TreeNode*> que;
que.push(root);
while(!que.empty())
{
int size = que.size();
int tmp;
TreeNode* dp;
for(int i = 0; i < size; i ++)
{
dp = que.front();
que.pop();
if(dp->left)
que.push(dp->left);
if(dp->right)
que.push(dp->right);
}
result.push_back(dp->val);
}
return result;
}
};
嘎嘎简单
题目链接(637):https://leetcode.cn/problems/average-of-levels-in-binary-tree/
代码:
class Solution {
public:
vector<double> averageOfLevels(TreeNode* root) {
vector<double> result;
queue<TreeNode*> que;
if(root == nullptr)
return result;
que.push(root);
while(!que.empty())
{
int size = que.size();
double sum = 0;
TreeNode* dp;
for(int i = 0; i < size; i ++ )
{
dp = que.front();
que.pop();
sum += dp->val;
if(dp->left)
que.push(dp->left);
if(dp->right)
que.push(dp->right);
}
double ave = sum/size;
result.push_back(ave);
}
return result;
}
};
题目链接(429):https://leetcode.cn/problems/n-ary-tree-level-order-traversal/submissions/
代码:
class Solution {
public:
vector<vector<int>> levelOrder(Node* root) {
queue<Node*> que;
vector<vector<int>> result;
if(root == nullptr)
return result;
que.push(root);
while(!que.empty())
{
int size = que.size();
Node* dp;
vector<int> tmp;
for(int i = 0; i < size; ++i)
{
dp = que.front();
que.pop();
tmp.push_back(dp->val);
for(int j = 0; j < dp->children.size();j++)
{
if(dp->children[j])
que.push(dp->children[j]);
}
}
result.push_back(tmp);
}
return result;
}
};
学会了n叉树多节点的孩子表示方法
题目链接(515):https://leetcode.cn/problems/find-largest-value-in-each-tree-row/submissions/
代码:
class Solution {
public:
vector<int> largestValues(TreeNode* root) {
queue<TreeNode*> que;
vector<int> result;
if(root == nullptr)
return result;
que.push(root);
while(!que.empty())
{
int size = que.size();
TreeNode* dp;
int max = INT_MIN;
for(int i = 0 ; i < size; ++i)
{
dp = que.front();
que.pop();
if(dp->val > max)
{
max = dp->val;
}
if(dp->left)
que.push(dp->left);
if(dp->right)
que.push(dp->right);
}
result.push_back(max);
}
return result;
}
};
最小值用INT_MIN表示,选最大值的时候可以用正则表达式来写:
max = dp->val > max?dp->val:max;
题目链接(116):https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/
代码:
class Solution {
public:
Node* connect(Node* root) {
queue<Node*> que;
if(root == NULL)
return root;
que.push(root);
while(!que.empty())
{
int size = que.size();
Node* dp;
Node* dp2;
for(int i = 0;i < size - 1; i++)
{
dp = que.front();
que.pop();
dp2 = que.front();
dp->next = dp2;
if(dp->left) que.push(dp->left);
if(dp->right) que.push(dp->right);
}
dp = que.front();
que.pop();
dp->next = NULL;
if(dp->left) que.push(dp->left);
if(dp->right) que.push(dp->right);
}
return root;
}
};
要注意:不能直接que.push(dp->left);que.push(dp->right);这样会把null放到队列中
也可以和代码随想录一样 获取前一个节点 然后对当前节点操作:
class Solution {
public:
Node* connect(Node* root) {
queue<Node*> que;
if (root != NULL) que.push(root);
while (!que.empty()) {
int size = que.size();
// vector<int> vec;
Node* nodePre;
Node* node;
for (int i = 0; i < size; i++) {
if (i == 0) {
nodePre = que.front(); // 取出一层的头结点
que.pop();
node = nodePre;
} else {
node = que.front();
que.pop();
nodePre->next = node; // 本层前一个节点next指向本节点
nodePre = nodePre->next;
}
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
nodePre->next = NULL; // 本层最后一个节点指向NULL
}
return root;
}
};
题目链接(117):https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/submissions/
代码:
class Solution {
public:
Node* connect(Node* root) {
if(root == NULL)
return root;
queue<Node*> que;
que.push(root);
while(!que.empty())
{
int size = que.size();
Node* prenode;
Node* node;
for(int i = 0; i < size;i++)
{
if(i == 0)
{
prenode = que.front();
que.pop();
if(prenode->left)
que.push(prenode->left);
if(prenode->right)
que.push(prenode->right);
}else
{
node = que.front();
que.pop();
prenode->next = node;
if(node->left)
que.push(node->left);
if(node->right)
que.push(node->right);
prenode = node;
}
}
prenode->next = NULL;
}
return root;
}
};
这不和上一题一样?
题目链接(104):https://leetcode.cn/problems/maximum-depth-of-binary-tree/
代码:
class Solution {
public:
int maxDepth(TreeNode* root) {
return root == nullptr ? 0 : max(maxDepth(root->left),maxDepth(root->right)) + 1;
}
};
这是递归方法,真的简单啊,但是就是很难想,应该说是不敢去想,这方面我还需要加强
再就是老方法:
class Solution {
public:
int maxDepth(TreeNode* root) {
if (root == NULL) return 0;
int depth = 0;
queue<TreeNode*> que;
que.push(root);
while(!que.empty()) {
int size = que.size();
depth++; // 记录深度
for (int i = 0; i < size; i++) {
TreeNode* node = que.front();
que.pop();
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
}
return depth;
}
};
题目链接(111):https://leetcode.cn/problems/minimum-depth-of-binary-tree/
代码:
class Solution {
public:
int minDepth(TreeNode* root) {
if(root == nullptr)
return 0;
if(root->left == nullptr && root->right)
return minDepth(root->right) + 1;
if(root->right == nullptr && root->left)
return minDepth(root->left) + 1;
return min(minDepth(root->left),minDepth(root->right)) + 1;
}
};
跟上一题差不多 但是要注意的是 如果根结点的左节点或者右节点为空 那么构不成子树没办法判断 所以要先判断一下
class Solution {
public:
int minDepth(TreeNode* root) {
if (root == NULL) return 0;
int depth = 0;
queue<TreeNode*> que;
que.push(root);
while(!que.empty()) {
int size = que.size();
depth++; // 记录深度
for (int i = 0; i < size; i++) {
TreeNode* node = que.front();
que.pop();
if(node->left == nullptr && node->right == nullptr)
return depth;
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
}
return depth;
}
};
层次遍历真容易啊。。。
226.翻转二叉树
题目链接:https://leetcode.cn/problems/invert-binary-tree/submissions/
代码:
class Solution {
public:
TreeNode* invertTree(TreeNode* root) {
inverse(root);
return root;
}
void inverse(TreeNode* root)
{
if(root == nullptr)
return;
TreeNode* tmp;
tmp = root->left;
root->left = root->right;
root->right = tmp;
inverse(root->left);
inverse(root->right);
}
};
击败100%的用户嘿嘿嘿
我这个是前序遍历,也可以用后序遍历,但是中序不行,交换过程的代码可以由这个替换:
swap(node->left, node->right);
中序的话:
inverse(root->left);
inverse(root->left);
视频链接:
https://www.bilibili.com/video/BV1sP4y1f7q7/?vd_source=3620d298fb5c81607e945a4dd 0315654
101. 对称二叉树
题目链接:
代码:
class Solution {
public:
bool isSymmetric(TreeNode* root) {
if(root == nullptr)
return true;
return compare(root->left,root->right);
}
bool compare(TreeNode* left,TreeNode* right)
{
if(left == nullptr && right != nullptr)
return false;
if(left != nullptr && right == nullptr)
return false;
if(left == nullptr && right == nullptr)
return true;
if(left->val != right->val)
return false;
bool out = compare(left->left,right->right);
bool in = compare(left->right,right->left);
return out&∈
}
};
看的代码随想录才会写的 用的是后序遍历