We run a preorder depth first search on the root
of a binary tree.
At each node in this traversal, we output D
dashes (where D
is the depth of this node), then we output the value of this node. (If the depth of a node is D
, the depth of its immediate child is D+1
. The depth of the root node is 0
.)
If a node has only one child, that child is guaranteed to be the left child.
Given the output S
of this traversal, recover the tree and return its root
.
Example 1:
Input: "1-2--3--4-5--6--7"
Output: [1,2,5,3,4,6,7]
Example 2:
Input: "1-2--3---4-5--6---7"
Output: [1,2,5,3,null,6,null,4,null,7]
Example 3:
Input: "1-401--349---90--88"
Output: [1,401,null,349,88,90]
Note:
- The number of nodes in the original tree is between
1
and1000
. - Each node will have a value between
1
and10^9
.
题目链接:https://leetcode.com/problems/recover-a-tree-from-preorder-traversal/
题目分析:一开始上来的思路比较直接,先把每个结点的值和深度记录下来,然后用两个栈模拟先序遍历的过程,一个栈用来存从输入中解析出的结点,一个栈用来存当前构造出来的TreeNode
11ms,时间击败22%
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
class Node {
int val;
int deep;
public Node(int val, int deep) {
this.val = val;
this.deep = deep;
}
}
public List<Node> getNodes(String S) {
List<Node> ans = new ArrayList<>();
int i = 0, deep = 0, val = 0;
while (i < S.length()) {
while (i < S.length() && S.charAt(i) >= '0' && S.charAt(i) <= '9') {
val = val * 10 + (S.charAt(i) - '0');
i++;
}
ans.add(new Node(val, deep));
deep = 0;
val = 0;
while (i < S.length() && S.charAt(i) == '-') {
deep++;
i++;
}
}
return ans;
}
public void recover(TreeNode root, List<Node> nodes) {
Stack<Node> stk = new Stack<>();
Stack<TreeNode> tstk = new Stack();
stk.push(nodes.get(0));
tstk.push(root);
int pos = 1;
while (!stk.empty() && pos < nodes.size()) {
while (!stk.empty() && stk.peek().deep + 1 != nodes.get(pos).deep) {
stk.pop();
tstk.pop();
}
root = tstk.peek();
while (root.left == null && pos < nodes.size() && stk.peek().deep + 1 == nodes.get(pos).deep) {
root.left = new TreeNode(nodes.get(pos).val);
stk.push(nodes.get(pos));
tstk.push(root.left);
pos++;
root = root.left;
}
if (root.right == null && pos < nodes.size() && stk.peek().deep + 1 == nodes.get(pos).deep) {
root.right = new TreeNode(nodes.get(pos).val);
stk.push(nodes.get(pos));
tstk.push(root.right);
pos++;
root = root.right;
}
}
}
public TreeNode recoverFromPreorder(String S) {
List<Node> nodes = getNodes(S);
TreeNode root = new TreeNode(nodes.get(0).val);
recover(root, nodes);
return root;
}
}
能用栈自然也能用递归咯,递归版
6ms,时间击败71.15%
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
class Node {
int val;
int deep;
public Node(int val, int deep) {
this.val = val;
this.deep = deep;
}
}
public List<Node> getNodes(String S) {
List<Node> ans = new ArrayList<>();
int i = 0, deep = 0, val = 0;
while (i < S.length()) {
while (i < S.length() && S.charAt(i) >= '0' && S.charAt(i) <= '9') {
val = val * 10 + (S.charAt(i) - '0');
i++;
}
ans.add(new Node(val, deep));
deep = 0;
val = 0;
while (i < S.length() && S.charAt(i) == '-') {
deep++;
i++;
}
}
return ans;
}
int pos = 1;
public void recover(TreeNode root, Node pre, List<Node> nodes) {
if (pos == nodes.size()) {
return;
}
Node cur = nodes.get(pos);
if (cur.deep == pre.deep + 1) {
root.left = new TreeNode(cur.val);
pos++;
recover(root.left, cur, nodes);
}
if (pos < nodes.size()) {
cur = nodes.get(pos);
if (cur.deep == pre.deep + 1) {
root.right = new TreeNode(cur.val);
pos++;
recover(root.right, cur, nodes);
}
}
}
public TreeNode recoverFromPreorder(String S) {
List<Node> nodes = getNodes(S);
TreeNode root = new TreeNode(nodes.get(0).val);
recover(root, nodes.get(0), nodes);
return root;
}
}
时间最优的解法应该是在DFS的过程中计算深度,而非提前记录下来