帮我写一个满足下列要求的JAVA代码问题描述：二叉树是一组有限的顶点，或者为空或者由根r和两个不相交的子二叉树组成，称为左右子树。它有3种最重要的遍历结点的方式，即先序、中序和后序。令T为由根r和子树T1和T2组成的二叉树，在T的先序遍历中，先访问根r，然后先序遍历T1，最后先序遍历T2，在T的中序遍历中，先中序遍历T1，然后访问根结点r，最后中序遍历T2；在T的后序遍历中，先后序遍历T1，然后后序遍历T2，最后访问r。 现在给出一颗二叉树的先序遍历序列和中序遍历序列，试着找出它的后序遍历序列。 输入格式：输入包含几个测试用例，每个测试用例的第一行包含一个整数n（1≤n≤1000），即二叉树的结点数，后面跟着两行，分别表示先序遍历序列和中序遍历序列，可以假设他们唯一构造一个二叉树。 输出格式：对于每个测试用例，打印一行指定相应是后序遍历序列。 输入样例： 9 1 2 4 7 3 5 8 9 6 4 7 2 1 8 5 9 3 6 输出样例： 7 4 2 8 9 5 6 3 1

以下是Java代码实现：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            int n = scanner.nextInt();
            int[] preOrder = new int[n];
            int[] inOrder = new int[n];
            for (int i = 0; i < n; i++) {
                preOrder[i] = scanner.nextInt();
            }
            for (int i = 0; i < n; i++) {
                inOrder[i] = scanner.nextInt();
            }
            int[] postOrder = getPostOrder(preOrder, inOrder);
            for (int i = 0; i < n - 1; i++) {
                System.out.print(postOrder[i] + " ");
            }
            System.out.println(postOrder[n - 1]);
        }
        scanner.close();
    }

    private static int[] getPostOrder(int[] preOrder, int[] inOrder) {
        int n = preOrder.length;
        int[] postOrder = new int[n];
        int root = preOrder[0];
        int rootIndex = 0;
        for (int i = 0; i < n; i++) {
            if (inOrder[i] == root) {
                rootIndex = i;
                break;
            }
        }
        int leftSize = rootIndex;
        int rightSize = n - rootIndex - 1;
        if (leftSize > 0) {
            int[] leftPre = new int[leftSize];
            int[] leftIn = new int[leftSize];
            for (int i = 0; i < leftSize; i++) {
                leftPre[i] = preOrder[i + 1];
                leftIn[i] = inOrder[i];
            }
            int[] leftPost = getPostOrder(leftPre, leftIn);
            System.arraycopy(leftPost, 0, postOrder, 0, leftSize);
        }
        if (rightSize > 0) {
            int[] rightPre = new int[rightSize];
            int[] rightIn = new int[rightSize];
            for (int i = 0; i < rightSize; i++) {
                rightPre[i] = preOrder[leftSize + i + 1];
                rightIn[i] = inOrder[rootIndex + i + 1];
            }
            int[] rightPost = getPostOrder(rightPre, rightIn);
            System.arraycopy(rightPost, 0, postOrder, leftSize, rightSize);
        }
        postOrder[n - 1] = root;
        return postOrder;
    }
}

算法思路：

- 根据题目给出的二叉树遍历方式，可以得到二叉树的根节点为先序遍历序列的第一个元素。
- 在中序遍历序列中找到根节点的位置，可以将中序遍历序列分成左子树和右子树两部分。
- 根据左子树和右子树的大小，可以将先序遍历序列和中序遍历序列分成左子树和右子树两部分。
- 对左子树和右子树分别递归求解后序遍历序列，最后将根节点加入到后序遍历序列的最后。

时间复杂度：$O(n\log n)$

空间复杂度：$O(n)$