根据中序序列+先序/后序构建二叉树

import java.util.*;

public class code08 {
    //根据中序序列和后序序列还原二叉树
    public static class TreeNode {
        int val;
        TreeNode left, right;

        TreeNode() {
        }

        TreeNode(int val) {
            this.val = val;
            left = null;
            right = null;
        }
    }

    //层序遍历
    public static List<Integer> cxOrder(TreeNode root) {
        if (root == null)
            return null;
        List<Integer> list = new ArrayList<>();
        Queue<TreeNode> que = new LinkedList<>();
        que.add(root);
        //无脑bfs
        while (!que.isEmpty()) {
            int size = que.size();
            while (size-- > 0) {
                TreeNode top = que.poll();
                if (top.left != null)//它这个自动的提示是多余的，它必不可能为空
                    que.add(top.left);
                if (top.right != null)
                    que.add(top.right);
                list.add(top.val);
            }
        }
        return list;
    }

    //根据中序遍历和后序遍历构造出二叉树
    public static TreeNode getBackTreeByInAndPost(List<Integer> inOrder, int inleft, int inright,
                                                  List<Integer> postOrder, int postleft, int postright) {
        if (inOrder == null || inOrder.size() == 0 || postOrder == null || postOrder.size() == 0 || inOrder.size() != postOrder.size())
            return null;
        if (inleft > inright || postleft > postright)
            return null;
        if (inleft < 0 || postleft < 0)
            return null;
        TreeNode root = new TreeNode(postOrder.get(postright));
        int index = getIndex(inOrder, inleft, inright, root.val);
        int leftSize = index - inleft;
        root.left = getBackTreeByInAndPost(inOrder, inleft, index - 1, postOrder, postleft, postleft + leftSize - 1);
        root.right = getBackTreeByInAndPost(inOrder, index + 1, inright, postOrder, postleft + leftSize, postright - 1);//用了以后就要少一个
        return root;
    }

    //根据中序序列和先序序列还原二叉树
    public static TreeNode getBackTreeByInAndPre(List<Integer> inOrder, int inleft, int inright,
                                                 List<Integer> preOrder, int preleft, int preright) {
        if (inOrder == null || inOrder.size() == 0 || preOrder == null || preOrder.size() == 0 || inOrder.size() != preOrder.size())
            return null;
        if (inleft > inright || preleft > preright)
            return null;
        if (inleft < 0 || preleft < 0)
            return null;
        TreeNode root = new TreeNode(preOrder.get(preleft));
        int index = getIndex(inOrder, inleft, inright, root.val);
        int leftSize = index - inleft;
        root.left = getBackTreeByInAndPre(inOrder, inleft, index - 1, preOrder, preleft + 1, preleft + leftSize);
        root.right = getBackTreeByInAndPre(inOrder, index + 1, inright, preOrder, preleft + leftSize + 1, preright);//用了以后就要少一个
        return root;
    }
    
    //找到中序序列中根的位置
    public static int getIndex(List<Integer> inOrder, int left, int right, Integer root) {
        for (int i = left; i <= right; i++) {
            if (Objects.equals(inOrder.get(i), root))
                return i;
        }
        return -1;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
       /* List<Integer> inorder = new ArrayList<>();
        List<Integer> postOrder = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            postOrder.add(sc.nextInt());
        }
        for (int i = 0; i < n; i++) {
            inorder.add(sc.nextInt());
        }
        TreeNode root = getBackTreeByInAndPost(inorder, 0, n - 1, postOrder, 0, n - 1);
        List<Integer> result = cxOrder(root);
        for (Integer num : result) {
            System.out.print(num + " ");
        }*/

        List<Integer> inorder = new ArrayList<>();
        List<Integer> preOrder = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            preOrder.add(sc.nextInt());
        }
        for (int i = 0; i < n; i++) {
            inorder.add(sc.nextInt());
        }
        TreeNode root = getBackTreeByInAndPre(inorder, 0, n - 1, preOrder, 0, n - 1);
        List<Integer> result = cxOrder(root);
        for (Integer num : result) {
            System.out.print(num + " ");
        }
    }
}