往期文章 :
目录
-
047. 二叉树剪枝
-
048. 序列化与反序列化二叉树(困难)
-
049. 从根节点到叶节点的路径数字之和
-
050. 向下的路径节点之和
-
051. 节点之和最大的路径(困难)
-
052. 展平二叉搜索树
==========================================================================
题目:
给定一个二叉树 根节点
root
,树的每个节点的值要么是0
,要么是1
。请剪除该二叉树中所有节点的值为0
的子树。
节点
node
的子树为node
本身,以及所有node
的后代。
示例:
输入: [1,0,1,0,0,0,1]
输出: [1,null,1,null,1]
解释:
只有红色节点满足条件“所有不包含 1 的子树”。
右图为返回的答案
提示:
-
二叉树的节点个数的范围是
[1,200]
-
二叉树节点的值只会是
0
或1
思路
后序遍历二叉树
遍历左右子树,若两边都为Null 且自己本身为0,则删除自己,返回Null给父节点
class Solution {
public:
TreeNode* pruneTree(TreeNode* root) {
return dfs(root);
}
//后序遍历,left -> right -> root
TreeNode* dfs(TreeNode* root) {
if(root == nullptr)
return nullptr;
//遍历左子树
root->left = dfs(root->left);
//遍历右子树
root->right = dfs(root->right);
//节点为0且是叶子结点就返回nullprt删除本节点
if(root->val == 0 && !root->right && !root->left) {
return nullptr;
}else {
//否则返回原本的树
return root;
}
}
};
====================================================================================
题目:
序列化是将一个数据结构或者对象转换为连续的比特位的操作,进而可以将转换后的数据存储在一个文件或者内存中,同时也可以通过网络传输到另一个计算机环境,采取相反方式重构得到原数据。
请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑,只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。
示例:
输入:root = [1,2,3,null,null,4,5]
输出:[1,2,3,null,null,4,5]
提示:
-
输入输出格式与 LeetCode 目前使用的方式一致,详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式,也可以采用其他的方法解决这个问题。
-
树中结点数在范围
[0, 104]
内 -
-1000 <= Node.val <= 1000
思路
字符串格式好像可以由自己设置,也可以参考提示LeetCode官方的格式:
string: "1,2,3,#,4"
---------TreeNode: ["1","2","3"","#","4"]
- 序列化
serialize
:前序遍历 根->左->右,为null
转为"#"
,然后就是"root, root->left, root->right"
格式添加字符串
- 反序列化deserialize:1. 分割字符串, 2. 前序遍历将字符串转换成二叉树
class Codec {
public:
// Encodes a tree to a single string.
string serialize(TreeNode* root) {
if(root == nullptr) {
return “#”;
}
string left = serialize(root->left);
string right = serialize(root->right);
//字符串形式为 “1,2,3,#,4”
return to_string(root->val) + “,” + left + “,” + right;
}
// Decodes your encoded data to tree.
TreeNode* deserialize(string data) {
//分割字符串 “1,2,3,#,4” -> [“1”,“2”,“3"”,“#”,“4”];
vector dataArray;
//第一个字符串的开头,添加空字符串是为了数字不只一个,需一个一个加入数组的字符串中
dataArray.push_back(“”);
for(auto& ch : data) {
if(ch == ‘,’) {
//在数组最后面添加一个空字符串,表示该该位数组的开头
dataArray.push_back(“”);
}else {
//数字不只一个字符ch,而是字符串,在数组的最后一个字符串每次加一个数组的字符
dataArray.back().push_back(ch);
}
}
int index = 0;
return dfs(dataArray, index);
}
// index记得使用引用,访问一个增加一次,在return null之前,否则无法顺利访问数组
TreeNode* dfs(vector& strs, int& index) {
string str = strs[index++];
if(str == “#”) {
return nullptr;
}
TreeNode* node = new TreeNode(stoi(str));
//index重点!!!必须这样,不然遇到空就不好访问数组
node->left = dfs(strs, index);
node->right = dfs(strs, index);
return node;
}
};
====================================================================================
题目:
给定一个二叉树的根节点
root
,树中每个节点都存放有一个0
到9
之间的数字。
每条从根节点到叶节点的路径都代表一个数字:
- 例如,从根节点到叶节点的路径
1 -> 2 -> 3
表示数字123
。
计算从根节点到叶节点生成的 所有数字之和 。
叶节点 是指没有子节点的节点。
示例:
输入:root = [4,9,0,5,1]
输出:1026
解释:
从根到叶子节点路径 4->9->5 代表数字 495
从根到叶子节点路径 4->9->1 代表数字 491
从根到叶子节点路径 4->0 代表数字 40
因此,数字总和 = 495 + 491 + 40 = 1026
提示:
-
树中节点的数目在范围
[1, 1000]
内 -
0 <= Node.val <= 9
-
树的深度不超过
10
思路
前序遍历
- 计算本节点的值 --> 上一节点 * 10 + 本节点
- 如果是叶子节点就直接返回该路径值
- 否则不是叶子节点,继续向下,并且将左右子树节点和返回
class Solution {
public:
int sumNumbers(TreeNode* root) {
return dfs(root, 0);;
}
int dfs(TreeNode* root, int ans) {
if(root == nullptr) return 0;
//当前节点表示的数
ans = ans * 10 + root->val;
//如果为叶子节点就返回本节点的值
if(root->left == nullptr && root->right == nullptr) {
return ans;
}else {
//不是叶子节点就返回左右子树的和
return dfs(root->left, ans) + dfs(root->right, ans);
}
}
};
==============================================================================
题目:
给定一个二叉树的根节点
root
,和一个整数targetSum
,求该二叉树里节点值之和等于targetSum
的 路径 的数目。
路径 不需要从根节点开始,也不需要在叶子节点结束,但是路径方向必须是向下的(只能从父节点到子节点)。
示例:
输入:root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8
输出:3
解释:和等于 8 的路径有 3 条,如图所示。
提示:
-
二叉树的节点个数的范围是
[0,1000]
-
-109 <= Node.val <= 109
-
-1000 <= targetSum <= 1000
思路
做这题之前先把 剑指 Offer II 010. 和为 k 的子数组 这题做会了就简单了。
这题就是 前缀和 + 回溯 + map
运用前缀和思想,求每一条路径的中间某一段路径和为
targetSum
的子路径
用
map
方便快速寻找路径和为sum - targetSum
的路径
若存在表示当前路径总和减去起点到某一节点和(前半部分)为
sum - targetSum
= 后半部分路径targetSum
class Solution {
public:
//剑指 Offer II 010. 和为 k 的子数组 这道题的扩展 前缀和
//将根节点到叶子结点的路径想象成 子数组, 运用010题的思路求解
unordered_map<int, int> map;
int pathSum(TreeNode* root, int targetSum) {
map[0] = 1;
return dfs(root, targetSum, 0);
}
int dfs(TreeNode* root, int targetSum, int sum) {
if(root == nullptr) return 0;
sum += root->val;
//代表从当前节点到前面某一节点的路径,某一节点前面的和在此前已经存入map
int count = map[sum - targetSum];
map[sum]++;
count += dfs(root->left, targetSum, sum) + dfs(root->right, targetSum, sum);
//回溯,要退回到本节点的上一层,所以不包含 map[sum]
map[sum]–;
return count;
}
};