每日打卡：从先序遍历还原二叉树

打卡： 从先序遍历还原二叉树

• 心情
• 读题
• 思路
• 实现
• 提交
• 标答

心情

《隐秘的角落》电视剧拍得太真实了，每个人都背负着枷锁走在这个世界上。有些时候看着自己的内心，就像是看着一个不相干的人在做着另一个世界的事情。

读题

leetcode： 1028. 从先序遍历还原二叉树

描述：
我们从二叉树的根节点 root 开始进行深度优先搜索。
在遍历中的每个节点处，我们输出 D 条短划线（其中 D 是该节点的深度），然后输出该节点的值。（如果节点的深度为 D，则其直接子节点的深度为 D + 1。根节点的深度为 0）。
如果节点只有一个子节点，那么保证该子节点为左子节点。
给出遍历输出 S，还原树并返回其根节点 root。

测试用例：
输入：“1-2–3--4-5–6--7”
输出：[1,2,5,3,4,6,7]
输入：“1-2–3—4-5–6—7”
输出：[1,2,5,3,null,6,null,4,null,7]
输入：“1-401–349—90–88”
输出：[1,401,null,349,88,90]

提示：
原始树中的节点数介于 1 和 1000 之间。
每个节点的值介于 1 和 10 ^ 9 之间。

先序遍历，二叉树，好熟悉~

思路

1：递归吧

实现

class Solution {
public TreeNode recoverFromPreorder(String S) {
TreeNode node = null;
if (S != null && S.length() > 0) {
String num = getNumber(S,"-");
node = new TreeNode(Integer.valueOf(num));
parseNode(node, S.substring(num.length()), "-");
}
return node;
}

/**
* 字符串转换为树
* @param node 当前节点
* @param str  左侧树
* @param trim 分割的字符串
* @return
*/
public String parseNode(TreeNode node, String str, String trim) {
if (str.length() > 0) {
String resultStr = trimStr(str, trim);
//strs[0]必然为空,不为空也不需要处理
//左侧树
if (str.length() - resultStr.length() == trim.length()) {
String num = getNumber(resultStr,"-");
node.left = new TreeNode(Integer.valueOf(num));
if (resultStr.length() > num.length()) {
str = parseNode(node.left, resultStr.substring(num.length()), trim + "-");
}else{
str = resultStr;
}
}
//右侧树
resultStr = trimStr(str, trim);
if (str.length() - resultStr.length() == trim.length()) {
String num = getNumber(resultStr,"-");
node.right = new TreeNode(Integer.valueOf(num));
if (resultStr.length() > num.length()) {
str = parseNode(node.right, resultStr.substring(num.length()), trim + "-");
}else{
str = resultStr;
}
}
}
return str;
}

/**
* 移除字符串前面的指定字符串
* @param str
* @param prefix
* @return
*/
public String trimStr(String str, String prefix) {
if (str.length() > 0 && str.startsWith(prefix)) {
return trimStr(str.substring(prefix.length()), prefix);
} else {
return str;
}
}

/**
* 获取字符串最前面的数值
* @param str
* @param prefix
* @return
*/
public String getNumber(String str, String prefix) {
if(str.indexOf(prefix)!=-1){
str = str.substring(0,str.indexOf(prefix));
}
return str;
}
}

还是比较清晰的思路，依次处理左节点再处理右节点。

提交

本想着用-分割子集，然后递归分割就能实现结果。结果卡在了第一步，用-分割子集要循环太多次……

标答

class Solution {
public TreeNode recoverFromPreorder(String S) {
// 存储当前节点的路径
Deque<TreeNode> path = new LinkedList<TreeNode>();
// 存储字符串中的位置
int pos = 0;
while (pos < S.length()) {
// 获取当前层数
int level = 0;
while (S.charAt(pos) == '-') {
++level;
++pos;
}
// 获取节点值
int value = 0;
while (pos < S.length() && Character.isDigit(S.charAt(pos))) {
value = value * 10 + (S.charAt(pos) - '0');
++pos;
}
// 构造当前节点
TreeNode node = new TreeNode(value);
if (level == path.size()) {
//如果当前节点的深度==当前路径长度（前一个节点是当前节点的父节点）
if (!path.isEmpty()) {
//如果不是第一个节点，前一个节点的左子节点为当前节点
path.peek().left = node;
}
}else {
//如果当前节点的深度！=当前路径长度（前一个节点不是当前节点的父节点）
while (level != path.size()) {
//通过queue弹出其他子节点，找到当前节点的父节点
path.pop();
}
// 找到父节点，因为此时左子节点已确定，所以赋值给右子节点
path.peek().right = node;
}
// 放入queue中
path.push(node);
}
// 全部弹出，只剩根节点
while (path.size() > 1) {
path.pop();
}
// 返回根
return path.peek();
}
}

官方题解