Leetcode--1028. 从先序遍历还原二叉树（Java）

我们从二叉树的根节点 root 开始进行深度优先搜索。

在遍历中的每个节点处，我们输出 D 条短划线（其中 D 是该节点的深度），然后输出该节点的值。（如果节点的深度为 D，则其直接子节点的深度为 D + 1。根节点的深度为 0）。

如果节点只有一个子节点，那么保证该子节点为左子节点。

给出遍历输出 S，还原树并返回其根节点 root。

 

示例 1：

输入："1-2--3--4-5--6--7"
输出：[1,2,5,3,4,6,7]

示例 2：

输入："1-2--3---4-5--6---7"
输出：[1,2,5,3,null,6,null,4,null,7]

示例 3：

输入："1-401--349---90--88"
输出：[1,401,null,349,88,90]

提示：

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

思路：

利用栈

两个相邻的结点只可能存在两种关系

1.后者是前者的左子节点

2.后者与前者无关，是更前面某一个节点的右子节点

/**

 * Definition for a binary tree node.

 * public class TreeNode {

 *     int val;

 *     TreeNode left;

 *     TreeNode right;

 *     TreeNode(int x) { val = x; }

 * }

 */

class Solution {

    public TreeNode recoverFromPreorder(String S) {

        if(S==null||S.length()==0){

            return null;

        }

        Stack<TreeNode> stack = new Stack<>();

        TreeNode root = new TreeNode(S.charAt(0)-'0');

        int index=0;

        while(index<S.length()){

            int level = 0;

          //记录当前找个节点处于第几层（通过看他前面有几条短线）

            while(S.charAt(index)=='-'){

                index++;

                level++;

            }

            int value = 0;

            while (index < S.length() && Character.isDigit(S.charAt(index))) {

                value = value * 10 + (S.charAt(index) - '0');

                ++index;

            }

            TreeNode temp = new TreeNode(value);

            //如果栈中节点遍历到的层数和新节点处于的层数一样，那么新节点是之前节点的左子节点，压入栈中

            if(level==stack.size()){

                if(!stack.isEmpty()){

                    stack.peek().left = temp;

                }

           //依次遍历到新节点父亲的层数，其他的出栈

            }else{

                while(level!=stack.size()){

                    stack.pop();

                }

                stack.peek().right=temp;

            }

            stack.push(temp);

        }

     //有的结点可能未出栈，依次退栈，只留下树根返回

        while(stack.size()>1){

            stack.pop();

        }

        return stack.peek();

    }

}