LeetCode 1028 Recover a Tree From Preorder Traversal (栈 或 DFS 推荐)

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 1and 1000.
• Each node will have a value between 1 and 10^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的过程中计算深度，而非提前记录下来