已知二叉树的前序和中序，请输出层序

已知二叉树的前序和中序，请输出层序

输入格式：

第一个数N，代表二叉树具有N个节点(N<50)

接着一行是N个整数，整数保证互不相同，整数之间有两个空格，表示前序

接着一行也是N个整数，整数之间有两个空格，表示中序

输出格式：

N个整数，整数之间有两个空格，表示层序

输入样例：

10
7 10 2 5 1 3 8 4 6 9
10 2 7 3 1 5 8 6 4 9

输出样例：

7 10 5 2 1 8 3 4 6 9

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Test19 {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int n = scanner.nextInt();
        if (n >= 50) {
            return;
        }
        int[] pre = new int[n];
        int[] in = new int[n];

        for (int i = 0; i < n; i++) {
            pre[i] = scanner.nextInt();
        }

        for (int i = 0; i < n; i++) {
            in[i] = scanner.nextInt();
        }

        TreeNode treeNode = reConstructBinaryTree(pre, in);

        leverOrder(treeNode);
    }

    static void leverOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        if (root == null) {
            return;
        }
        queue.add(root);
        while (!queue.isEmpty()) {
            TreeNode remove = queue.remove();
            if (remove.left != null) {
                queue.add(remove.left);
            }
            if (remove.right != null) {
                queue.add(remove.right);
            }
            System.out.print(remove.val + "  ");
        }
    }
    
/**
* pre：线序遍历得到的数组
* in：中序遍历得到的数组
*/
    static public TreeNode reConstructBinaryTree(int[] pre, int[] in) {
        return getRootTreeNode(pre, 0, pre.length - 1, in, 0, in.length - 1);
    }

    /**
     * preL：当前子树在先序遍历的数组中的起始下标
     * preR：当前子树在先序遍历的数组中的结束下标
     * inL：当前子树在中序遍历的数组中的起始下标
     * inR：当前子树在中序遍历的数组中的起始下标
     */
    static public TreeNode getRootTreeNode(int[] pre, int preL,
                                           int preR, int[] in, int inL, int inR) {
        if (preL > preR) {
            return null;
        }

        TreeNode node = new TreeNode(pre[preL]);

        for (int i = inL; i <= inR; ++i) {
            if (in[i] == pre[preL]) {

                node.left = getRootTreeNode(pre, preL + 1, preL + i - inL, in, inL, i - 1);
                node.right = getRootTreeNode(pre, preL + i - inL + 1, preR, in, i + 1, inR);
                break;
            }
        }

        return node;
    }
}

class TreeNode {
    int val;        //当前节点的值
    TreeNode left;    //左子节点
    TreeNode right;    //右子节点

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