简单
翻转二叉树
/**
* 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) {
if(!root) return 0;
TreeNode* tmp;
tmp = root->left;
root->left = root->right;
root->right = tmp;
invertTree(root->left);
invertTree(root->right);
return root;
}
};
成绩:100 85.17
思路:
一开始想着是不是把数值swap一下就好了。然后看到左子树整棵变成右子树了,那八成是换结构了。那就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:
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
int low = min(p->val,q->val);
int up = max(p->val,q->val);
if(low<=root->val && up>=root->val) return root;
else if(up<root->val) return lowestCommonAncestor(root->left,p,q);
else return lowestCommonAncestor(root->right,p,q);
}
};
成绩:72.62 44.54
思路:
要利用好二叉搜索树“左子节点小于根节点,右子节点大于根节点”这一特性。
当指定节点数值相较于当前节点数值一大一小时,说明两者分别在当前节点的左右子树,那么当前节点即为最近公共祖先;
如果两个指定节点数值均比当前节点数值小,说明均在左子树,就向左子树递归;
反之则向右子树递归。
二叉树的所有路径
/**
* 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:
void print(TreeNode* root,vector<int>& path,vector<string>& res){
path.push_back(root->val);
//如果是叶子节点,将路径格式化输出
if(root->left==nullptr && root->right==nullptr){
int i = 0;
string s = "";
for(i;i<path.size()-1;i++){
s = s+to_string(path[i]);
s += "->";
}
s = s+to_string(path[i]);
res.push_back(s);
}
//若不是,递归
if(root->left){
print(root->left,path,res);
path.pop_back();
}
if(root->right){
print(root->right,path,res);
path.pop_back();
}
}
vector<string> binaryTreePaths(TreeNode* root) {
vector<string> res;
vector<int> path;
print(root,path,res);
return res;
}
};
成绩:74.22 68.24
思路:
这题最关键的是回溯,真正意义上的回溯,包括怎么回溯,什么时候回溯。
可以看看carl的题解,写的确实不错。
其实这里面的有一个点我感觉不能直接按照回溯去理解。就是
这个回溯就要很大的问题,我们知道,回溯和递归是一一对应的,有一个递归,就要有一个回溯,这么写的话相当于把递归和回溯拆开了, 一个在花括号里,一个在花括号外。
所以回溯要和递归永远在一起,世界上最遥远的距离是你在花括号里,而我在花括号外!
那么代码应该这么写:
if (cur->left) { traversal(cur->left, path, result); path.pop_back(); // 回溯 } if (cur->right) { traversal(cur->right, path, result); path.pop_back(); // 回溯 }
这里直接把pop_back()的操作,即回溯是需要做的删除子节点这一操作写成是回溯,但其实回溯是由
if(递归终止条件){
递归终止逻辑
}
来形成的。对于懂的人当然无伤大雅,但写清楚终究是好事。
左叶子之和
/**
* 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:
void cumulation(TreeNode* root,int& sum){
if(root->left == nullptr && root->right == nullptr){
return;
}
if(root->left){
if(root->left->left == nullptr && root->left->right == nullptr) sum+=root->left->val;
cumulation(root->left,sum);
}
if(root->right){
cumulation(root->right,sum);
}
}
int sumOfLeftLeaves(TreeNode* root) {
int sum = 0;
cumulation(root,sum);
return sum;
}
};
成绩:25.43 93.68
思路:
DFS的框架是简单的,最重要的是找出左叶子节点。当然叶子节点自己是不知道自己是左叶子还是右叶子,要靠父节点来判断。当root有左子树时,就要判断左子树是不是叶子节点。如果是就计入sum。如果不是就继续往左子树遍历。
但是这个代码肯定是可以优化的,隐隐感觉可以更快回溯,明天再想想。可不可以记录当前节点root,若下一节点root->child是叶子节点,则看看root->child是不是root的左孩子,若是则加。感觉这样比较靠谱。
二叉搜索树中的众数
/**
* 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 judge(int val,unordered_map<int,int>& hash){
if(hash.find(val) == hash.end()) return false;
return true;
}
void DFS(TreeNode* root, unordered_map<int,int>& hash){
if(!root) return;
if(judge(root->val,hash)) {
//就是非新节点值,键值加一
hash[root->val] += 1;
}
//若为新节点,则加入hash
else hash.emplace(root->val,1);
DFS(root->left,hash);
DFS(root->right,hash);
}
vector<int> findMode(TreeNode* root) {
unordered_map<int,int> hash;
DFS(root,hash);
auto it = hash.begin();
vector<int> maxkey;
int max = 0;
for(it;it!=hash.end();it++){
if(it->second>max) {
maxkey.clear();
max = it->second;
maxkey.push_back(it->first);
}
else if(it->second == max){
maxkey.push_back(it->first);
}
}
return maxkey;
}
};
分数:15.48 5.08
思路:
一目了然了就是,利用hash进行存储,利用DFS遍历二叉搜索树,最后根据每一个节点的次数输出最多出现的节点值。
这个方法确实是很慢,从代码里也可以看出。但是好歹是做出来了。
二叉树的直径
/**
* 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 DFS(TreeNode* root,int& res){
if(!root) return 0;
int l = DFS(root->left,res);
int r = DFS(root->right,res);
res = max(res,l+r); //记录以所有节点为根节点的直径。这一步很重要
return max(l,r)+1;
}
int diameterOfBinaryTree(TreeNode* root) {
int res = 0;
DFS(root,res);
return res;
}
};
成绩:76.26 96.70
思路:
一开始我想的就是左子树深度加上右子树深度,也就是说我认为这条最长的路径一定是经过根节点的。但是提交之后发现在第100个检测样例卡住了,一画才发现是有可能不过根节点的。
那既然有可能是不过根节点的,怎么样才能找到最长路径中的那一个“根节点”呢?最后发现,还是逃不掉遍历所有节点。只要找到这条路径上的这一个“根节点”,那么二叉树直径就是以该节点为根节点的左右子树深度和。
那么如何取实现这一步,就是看我们对树的DFS的掌握程度了。我们什么时候才能得到某个节点的左子树深度与右子树深度呢?是当回溯到该节点时才能得到两者,注意是回溯。也就是说已经结束了DFS(left)和DFS(right),但该节点还没有往回回溯的时候。所以我们首先创建一个全局变量res(我不喜欢全局变量所以给了一个引用回去,都一样),在每一次左右子树遍历完回溯到“根节点”时,取当前节点的左右子树深度和l+r(也就是以该节点为根节点的直径)与res较大者。最后主函数输出res,即为当前树的直径。
找树左下角的值
思路
DFS+深度判断
其实不用管什么左下角,只要满足两个条件,当前节点就是我们需要的节点:
1、最底层
2、最左边
那么如何实现这两个条件的判断,我们就需要一个depth变量来记录当前深度,若当前节点非叶子节点,则继续向左右子节点遍历;若当前节点为子节点,则判断当前深度变量depth是否大于最大深度变量maxdepth,若前者较大,说明当前节点处于最底层且为最左边的节点(因为是第一次遍历到,否则就应该是depth == maxdepth)
代码
/**
* 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:
void DFS(TreeNode* root,int& depth, int& maxdepth, int& res){
depth += 1;
if(root->left == nullptr && root->right == nullptr){
if(depth > maxdepth){
res = root->val;
maxdepth = depth;
}
}
if(root->left){
DFS(root->left,depth,maxdepth,res);
depth -= 1;
}
if(root->right){
DFS(root->right,depth,maxdepth,res);
depth -= 1;
}
}
int findBottomLeftValue(TreeNode* root) {
int depth = 0;
int maxdepth = 0;
int res = 0;
DFS(root,depth,maxdepth,res);
return res;
}
};
复杂度分析
时间复杂度:O(n) n为节点个数
空间复杂度:O(h) h为最大深度
求根到叶子节点数字之和
这题和二叉树的所有路径其实是一模一样的,两题可以一起做。
思路
其实就是遍历所有路劲,无非就是设置一个数记录往下遍历和回溯后路径上数的变化。
代码
/**
* 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:
void DFS(TreeNode* root,int& sum, int &cur){
cur = cur*10+root->val;
if(root->left == nullptr && root->right == nullptr) sum += cur;
if(root->left){
DFS(root->left,sum,cur);
cur = cur/10;
}
if(root->right){
DFS(root->right,sum,cur);
cur = cur/10;
}
}
int sumNumbers(TreeNode* root) {
int sum = 0;
int cur = 0;
DFS(root,sum,cur);
return sum;
}
};
复杂度分析
时间复杂度:O(n) n为节点个数
空间复杂度:O(h) h为树的深度,其实就是递归栈