题源codetop标签近半年+树
1.二叉树的层序遍历
层序遍历一般写法，通过一个while循环控制从上向下一层层遍历，for循坏控制每一层从左到右
class Solution{
public:
vector<vector<int>> levelOrder(TreeNode* root){
vector<vector<int>> res;
if(root == nullptr) return res;
queue<TreeNode*> q;
q.push(root);
// while循环控制从上到下
while(!q.empty()){
int size = q.size();
vector<int> level;
// for循环
for(int i = 0; i < sz; i ++){
TreeNode* cur = q.front();
q.pop();
level.push_back(cur->val);
if(cur->val != nullptr) q.push(cur->left);
if(cur->val != nullptr) q.push(cur->right);
}
res.push_back(level);
}
return res;
}
};
2.二叉树的层序遍历II
返回其节点值 自底向上 的层序遍历。
用双端队列存储
class Solution {
public:
vector<vector<int>> levelOrderBottom(TreeNode* root) {
deque<vector<int>> res;
if(root == nullptr) return vector<vector<int>>(res.begin(), res.end());
queue<TreeNode*> q;
q.push(root);
while(!q.empty()){
int size = q.size();
vector<int> level;
for(int i = 0; i < size; i ++){
TreeNode* cur = q.front();
q.pop();
level.push_back(cur->val);
if(cur->left != nullptr) q.push(cur->left);
if(cur->right != nullptr) q.push(cur->right);
}
res.push_front(level);//重点！！！
}
return vector<vector<int>>(res.begin(), res.end());
}
};
3.二叉树的锯齿形层次遍历
给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
和层次遍历是一样的，只是多用一个flag来控制遍历方向。flag 为 true 时向右，false 时向左。
class Solution{
public:
vector<vector<int>> zigzagLevelOrder(TreeNode* root){
vector<vector<int>> res;
if(root == nullptr) return res;
queue<TreeNode*> q;
q.push(root);
bool flag = true;
while(!q.empty()){
int size = q.size();
deque<int> level;// 双端队列
for(int i = 0; i < size; i ++){
TreeNode* cur = q.front();
q.pop();
if(flag){
level.push_back(cur->val);
}else{
level.push_front(cur->val);
}
if(cur->left != nullptr) q.push(cur->left);
if(cur->right != nullptr) q.push(cur->right);
}
flag = !flag;// 一层结束切换方向
res.push_back(vector<int>(level.begin(), level.end()));
}
return res;
}
};
4.N叉树的层次遍历
class Solution {
public:
vector<vector<int>> levelOrder(Node* root) {
vector<vector<int>> res;
if(root == nullptr) return res;
queue<Node*> q;
q.push(root);
while(!q.empty()){
int size = q.size();
vector<int> level;
for(int i = 0; i < size; i ++){
Node* cur = q.front();
q.pop();
level.push_back(cur->val);
for(Node* child : cur->children) q.push(child);
}
res.push_back(level);
}
return res;
}
};
5.二叉树的最近公共祖先
// 1. 先看根节点是不是祖先
if(root==null || root==p || root==q){
return root;
}
// 2. 如果根节点是祖先，有没有更近的祖先呢
// 看看左子树
TreeNode left = lowestCommonAncestor(root.left, p, q);
// 看看右子树
TreeNode right = lowestCommonAncestor(root.right, p, q);
// 3. 如果有的话显然只会在一侧 判断一下
if(left==null){
return right;
}
if(right==null){
return left;
}
// 4. 如果没有更近的，默认还是返回root
return root;
}
6.二叉搜索树的最近公共祖先
- 如果p和q都比当前节点小，那么p和q显然都在左子树
- 如果p和q都比当前节点大，那么p和q显然都在右子树
- 一旦发现p和q都在当前节点两侧，那么当前节点就是
class Solution{
public:
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q){
if(root == nullptr) return nullptr;
if(p->val > q->val) return lowestCommonAncestor(root, q, p);// 保证p.val < q.val,便于讨论
if(root->val >= p->val && root->val <= q->val) return root;
if(root->val > q->val) return lowestCommonAncestor(root->left, p, q);// p和q都在左子树
else return lowestCommonAncestor(root->right, p, q);//其余条件都排除了，只剩root.val < p.val这一个，所以这个else是安全的
}
};
7.二叉树的直径
所谓二叉树的直径，就是左右子树的最大深度之和。
那么直接想法是对每个节点计算左右子树的最大高度，得出每个节点的直径，从而得出最大的那个直径。
class Solution {
public:
int maxDiameter = 0; // 存储最大直径
int diameterOfBinaryTree(TreeNode* root) {
maxdepth(root); // 调用辅助函数
return maxDiameter; // 返回已计算的最大直径
}
int maxdepth(TreeNode* root) {
if (root == nullptr) return 0; // 空节点的深度为0
int leftMax = maxdepth(root->left); // 左子树的最大深度
int rightMax = maxdepth(root->right); // 右子树的最大深度
int myDiameter = leftMax + rightMax; // 经过当前节点的最长路径长度
maxDiameter = max(maxDiameter, myDiameter); // 更新全局最大直径
return max(leftMax, rightMax) + 1; // 返回节点的最大深度
}
};
maxdepth 函数最后返回 max(leftMax, rightMax) + 1 是为了：
- 计算当前节点的最大深度，以便于父节点计算其最大深度。
- 更新整个二叉树的直径，即最长路径的长度。
8.二叉树中最大路径和
二叉树中的 路径 被定义为一条节点序列，序列中每对相邻节点之间都存在一条边。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点，且不一定经过根节点。
路径和 是路径中各节点值的总和。
给你一个二叉树的根节点 root ，返回其 最大路径和 。
oneSideMax 函数和上述几道题中都用到的 maxDepth 函数非常类似，只不过 maxDepth 计算最大深度，oneSideMax 计算「单边」最大路径和，只记录左子树或者右子树最大路径和，然后在后序遍历的时候顺便计算题目要求的最大路径和。
class Solution{
public:
int res = INT_MIN;
int maxPathSum(TreeNode* root){
if(root == nullptr) return 0;
oneSideMax(root);
return res;
}
int oneSideMax(TreeNode* root){
if(root == nullptr) return 0;
int leftMaxSum = max(0, oneSideMax(root->left));
int rightMaxSum = max(0, oneSideMax(root->right));
int pathMaxSum = root->val + leftMaxSum + rightMaxSum;
res = max(res, pathMaxSum);
return root->val + max(leftMaxSum, rightMaxSum);
}
9.二叉树的中序遍历
创建一个栈来保存遍历过程中的节点，首先尽可能将节点的左子节点入栈，直到左子节点不存在为止。当左子节点访问完毕后，从栈中弹出一个节点，访问该节点（输出节点值），然后转向访问该节点的右子节点。
class Solution {
public:
vector<int> inorderTraversal(TreeNode* root) {
vector<int> res;
stack<TreeNode*> stk;
while (root != nullptr || !stk.empty()) {
while (root != nullptr) {
stk.push(root);
root = root->left;
}
root = stk.top();
stk.pop();
res.push_back(root->val);
root = root->right;
}
return res;
}
};
10.从前序与中序遍历序列构造二叉树
给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。
构造二叉树，第一件事一定是找根节点，然想办法构造左右子树。前序遍历的第一个结果就是根节点的值，然后再根据中序遍历结果确定左右子树的节点。
class Solution {
// 存储 inorder 中值到索引的映射,找根节点在 inorder 中的位置
unordered_map<int, int> valToIndex;
public:
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
for(int i = 0; i < inorder.size(); i ++) valToIndex[inorder[i]] = i;
return build(preorder, 0, preorder.size() - 1, inorder, 0, inorder.size() - 1);
}
private:
TreeNode* build(vector<int>& preorder, int preStart, int preEnd, vector<int>& inorder, int inStart, int inEnd){
if(preStart > preEnd) return nullptr;
int rootVal = preOrder[preStart];
int index = valToIndex[rootVal];
int leftSize = index - inStart;
//构造当前根节点
TreeNode* root = new TreeNode(rootVal);
//递归构造左右子树
root->left = build(preorder, preStart + 1, preStart + leftSize, inorder, inStart, index - 1);
root->right = build(preorder, preStart + leftSize + 1, preEnd, inorder, index + 1, inEnd);
return root;
11.从中序与后序遍历序列构造二叉树
给inorder和postorder数组，其中inorder是二叉树中的中序遍历，postorder是同一棵树的后序遍历。
class Solution {
public:
unordered_map<int, int> valToIndex;
TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
for(int i = 0; i < inorder.size(); i ++) valToIndex[inorder[i]] = i;
return build(inorder, 0, inorder.size() - 1, postorder, 0, postorder.size() - 1);
}
TreeNode* build(vector<int>& inorder, int inPre, int inEnd, vector<int>& postorder, int postPre, int postEnd){
if(postPre > postEnd) return nullptr;
int rootVal = postorder[postEnd];
int index = valToIndex[rootVal];
int leftsize = index - inPre;
TreeNode* root = new TreeNode(rootVal);
root->left = build(inorder, inPre, index - 1, postorder, postPre, postPre + leftsize - 1);
root->right = build(inorder, index + 1, inEnd, postorder, postPre + leftsize, postEnd - 1);
return root;
}
};
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
