LeetCode树专题
LeetCode树专题
98. 验证二叉搜索树
二叉搜索树，每个结点的值都有一个范围
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool isValidBST(TreeNode* root) {
return dfs(root,INT_MIN,INT_MAX);
}
bool dfs(TreeNode* root,long long l,long long r){
if(!root) return true;
//判断当前结点
if(root->val < l || root->val > r) return false;
//递归判断左右子节点
return dfs(root->left,l,root->val - 1ll) && dfs(root->right,root->val+1ll,r);
}
};
94. 二叉树的中序遍历
二叉树中序遍历的迭代写法
模拟中序遍历
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
vector<int> inorderTraversal(TreeNode* root) {
vector<int> result;
stack<TreeNode*> stk;
auto p = root;
while(p || stk.size()){
while(p){ //1.把左子树全部加入栈中
stk.push(p);
p = p->left;
}
p = stk.top(); //2.取栈首 输出栈首
stk.pop();
result.push_back(p->val);
p = p->right; //3.转到右子树
}
return result;
}
};
101. 对称二叉树
用递归和迭代两种做法
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool isSymmetric(TreeNode* root) {
if(!root) return true;
return dfs(root->left,root->right);
}
bool dfs(TreeNode* p,TreeNode* q){
if(!p || !q) return !p && !q; //左右不能一空一不空
//1.比较当前两结点的值
//2.比较p结点左子树和q结点右子树
//3.比较p结点右子树和q结点左子树
return p->val == q->val &&
dfs(p->left,q->right) && dfs(p->right,q->left);
}
};
迭代：左边左中右，右边右中左；每次遍历对应两个结点比较值是否相等
类似LeetCode94的迭代遍历二叉树的思路
105. 从前序与中序遍历序列构造二叉树
假设树中没有重复的元素。
根据一棵树的前序遍历与中序遍历构造二叉树。
前序序列确定根
在中序序列中找到根的值，那么根左边为左子树序列，右边为右子树序列
前序序列下一个结点是左子树的根；
前序序列当前位置加上左子树的大小的下一个原始就是右子树的根；
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
unordered_map<int,int> mp;
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
int n = preorder.size();
for(int i=0;i<n;i++) mp[inorder[i]] = i; //哈希表预统计中序各元素所在下标
return dfs(preorder,inorder,0,n-1,0,n-1);
}
TreeNode* dfs(vector<int>& preorder,vector<int>& inorder,int pl,int pr,int il,int ir){
if(pl > pr) return NULL;
int value = preorder[pl];
int pos = mp[value]; //找到根在中序序列中的位置
int len = pos-il; //左子树元素个数
auto root = new TreeNode(value); //建立根
root->left = dfs(preorder,inorder,pl+1,pl+len,il,pos-1); //建左子树
root->right = dfs(preorder,inorder,pl+len+1,pr,pos+1,ir); //建右子树
return root;
}
};
102. 二叉树的层序遍历
以层为单位
bfs分别统计每一层
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> result;
if(!root) return result; //边界判断 特判root为空
queue<TreeNode*> q;
q.push(root);
while(q.size()){
vector<int> levelList;
int len = q.size(); //循环刚进来 代表上一层的元素个数
for(int i=1;i<=len;i++){
//把当前层每一个元素分别出队 并把左右结点入队
auto top = q.front();
q.pop();
levelList.push_back(top->val);
if(top->left) q.push(top->left);
if(top->right) q.push(top->right);
}
result.push_back(levelList);
}
return result;
}
};
236. 二叉树的最近公共祖先
思路：来源leetcode题解
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
//递归出口
if(root == NULL || root == p || root == q) return root;
//递归统计左右结点
auto left = lowestCommonAncestor(root->left,p,q);
auto right = lowestCommonAncestor(root->right,p,q);
//只在一个子树上
if(left == NULL) return right;
if(right == NULL) return left;
//否则left和right都非空
//说明一个结点在其左子树 另一个结点在右子树那么当前结点就是最近公共祖先
return root;
}
};
543. 二叉树的直径
直径：树中最长的路径(从一点到另一点)
注意：因为一开始不确定最高点是哪个，根节点不一定是最高点，比如下图样例
所以在dfs的过程上枚举最高点，就是计算当前结点下ans的最大值
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
int ans = 0; //最优值
int diameterOfBinaryTree(TreeNode* root) {
dfs(root);
return ans;
}
int dfs(TreeNode* root){
if(!root) return 0;
int left = dfs(root->left);
int right = dfs(root->right);
//加入当前结点后的最优值: 左子树深度 + 右子树深度
ans = max(ans,left+right); //更新当前节点下 最长直径长度
return max(left,right); //返回当前树上 左右子树的最大值
}
};
其它做法：
先找到一个深度最深的端点(最高点)，再把最高点作为根dfs找到新的最深距离
https://www.cnblogs.com/fisherss/p/10914820.html
124. 二叉树中的最大路径和
从树中任意节点出发，达到任意节点的序列的最大路径和
和LeetCode543思路一样，dfs的过程中枚举最优点(最高点)，即最优点下路径和最大，其对应所在的一条路径上权值和最大，所在的路径为左子树路径+本身+右子树
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
int ans = INT_MIN;
int maxPathSum(TreeNode* root) {
dfs(root);
return ans;
}
//从当前结点root向下走的最大值
int dfs(TreeNode* root){
if(!root) return 0;
int left = dfs(root->left);
int right = dfs(root->right);
//dfs枚举到最优点下 更新加入当前结点后的最优值
ans = max(ans,left+root->val+right); //左边最大值 + 自己 + 右边最大值
/*
//下面三行都可以省略替代为上一行
//因为dfs左右子树后 左右子树已达最优 只要再加入当前结点的值就行
ans = max(ans,root->val);
ans = max(ans,left+root->val);
ans = max(ans,right+root->val);
*/
//三种情况和0比较
return max(0,max(root->val,max(left+root->val,right+root->val)));
}
};
173. 二叉搜索树迭代器
题目描述：
实现一个二叉搜索树迭代器。你将使用二叉搜索树的根节点初始化迭代器。
调用 next() 将返回二叉搜索树中的下一个最小的数。
题目要求：
思路：
二叉搜索树每次返回一个最小的数，就相当于对二叉搜索树进行中序遍历
因为二叉搜索树的左子树都比根小，右子树都比根大；即左、中、右的值依次增大
递归方式(不满足空间要求)：
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class BSTIterator {
public:
vector<int> v;
int pos = 0;
BSTIterator(TreeNode* root) {
dfs(root);
}
void dfs(TreeNode* root){
if(!root) return;
dfs(root->left);
v.push_back(root->val);
dfs(root->right);
}
/** @return the next smallest number */
int next() {
return v[pos++];
}
/** @return whether we have a next smallest number */
bool hasNext() {
if(pos < v.size()) return true;
return false;
}
};
/**
* Your BSTIterator object will be instantiated and called as such:
* BSTIterator* obj = new BSTIterator(root);
* int param_1 = obj->next();
* bool param_2 = obj->hasNext();
*/
迭代方式(用栈来模拟中序遍历)：
参考LeetCode94，只不过是把迭代拆开写了
满足next函数内存是O(h)，即栈中最多加入了一列深度下的节点
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class BSTIterator {
public:
stack<TreeNode*> stk;
BSTIterator(TreeNode* root) {
while(root){ //初始加入左子树入栈
stk.push(root);
root = root->left;
}
}
/** @return the next smallest number */
int next() { //O(h)
auto p = stk.top(); //二叉搜索树中序的栈顶一定是最小的
stk.pop();
int result = p->val;
p = p->right; //左子树遍历完了 根也遍历完了 就移向右子树
while(p){
stk.push(p);
p = p->left;
}
return result;
}
/** @return whether we have a next smallest number */
bool hasNext() {
return !stk.empty();
}
};
/**
* Your BSTIterator object will be instantiated and called as such:
* BSTIterator* obj = new BSTIterator(root);
* int param_1 = obj->next();
* bool param_2 = obj->hasNext();
*/
297. 二叉树的序列化与反序列化
序列化相当于先序遍历序列，NULL值用#代替；
反序列化相当于用带#表示空值的先序序列来建树(本来只用先序序列无法建树，但是这里使用了#来代表叶节点孩子的值为空，就可以用先序建树了)
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Codec {
public:
// Encodes a tree to a single string.
string serialize(TreeNode* root) {
string data;
dfs1(root,data);
return data;
}
void dfs1(TreeNode* root,string &data){
if(!root){
data += "#,";
return;
}
data += to_string(root->val) + ','; //先序遍历
dfs1(root->left,data);
dfs1(root->right,data);
}
// Decodes your encoded data to tree.
TreeNode* deserialize(string data) {
int index = 0;
return dfs2(data,index);
}
TreeNode* dfs2(string &data,int &index){
if(data[index] == '#'){ //遇到#号 要消耗一个,和一个#
index+=2;
return NULL;
}
bool is_minus = false;
if(data[index] == '-') { //判断是否是负数
is_minus = true;
index++;
}
int value = 0;
while(data[index] != ','){ //求这个数的值 到下一个逗号结束
value = value * 10 + (data[index] - '0');
index++;
}
index++;
if(is_minus) value = -value; //负数
auto root = new TreeNode(value); //建立根节点
root->left = dfs2(data,index); //递归求左右子树
root->right = dfs2(data,index);
return root;
}
};
// Your Codec object will be instantiated and called as such:
// Codec codec;
// codec.deserialize(codec.serialize(root));
