（Java）1020 Tree Traversals分数 25

最新推荐文章于 2025-11-25 11:31:36 发布

原创最新推荐文章于 2025-11-25 11:31:36 发布 · 112 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #java

PTA甲级算法题专栏收录该内容

30 篇文章

订阅专栏

文章讲解了如何利用后序和中序遍历构造二叉树，然后通过层次遍历算法求得给定序列对应的树的级序遍历结果。

Suppose that all the keys in a binary tree are distinct positive integers. Given the postorder and inorder traversal sequences, you are supposed to output the level order traversal sequence of the corresponding binary tree.

假设二叉树中的所有键都是不同的正整数。给定后序和序遍历序列，您应该输出相应二叉树的级序遍历序列。

Input Specification:

Each input file contains one test case. For each case, the first line gives a positive integer N (≤30), the total number of nodes in the binary tree. The second line gives the postorder sequence and the third line gives the inorder sequence. All the numbers in a line are separated by a space.

每个输入文件包含一个测试用例。对于每种情况，第一行给出一个正整数N（≤30），即二叉树中的节点总数。第二行给出了后序序列，第三行给出了有序序列。一行中的所有数字都用空格隔开。

Output Specification:

For each test case, print in one line the level order traversal sequence of the corresponding binary tree. All the numbers in a line must be separated by exactly one space, and there must be no extra space at the end of the line.

对于每个测试用例，在一行中打印相应二叉树的级别顺序遍历序列。一行中的所有数字必须正好用一个空格分隔，并且行的末尾不能有多余的空格。

Sample Input:

7
2 3 1 5 7 6 4
1 2 3 4 5 6 7

Sample Output:

4 1 6 3 5 7 2

思路：我们可以通过中序遍历 + 后序遍历构造出一颗唯一的二叉树（前序+后序不能构造出一颗唯一的二叉树！！），然后通过层序遍历得到答案，中序 + 后序遍历构造出二叉树可以参考一下leetcode 106题

从中序与后序遍历序列构造二叉树

import java.util.*;
class Main{
    static int[]postorder ;
    static int[]inorder;
    static int n;
    static Map<Integer,Integer> map = new HashMap<>();
    static int post_index;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        postorder = new int[n];
        inorder = new int[n];
        for(int i = 0 ; i < n ;i++)
        {
            postorder[i] = sc.nextInt();

        }
        for(int i = 0 ; i < n ;i++)
        {
            inorder[i] = sc.nextInt();
        }
        post_index = n - 1;
        int index = 0;
        for(int k :inorder)
        {
            map.put(inorder[index] , index++);
        }
        TreeNode root = BuilderTree(0,n-1);

        Queue<TreeNode> q = new LinkedList<>();
        q.offer(root);
        ArrayList<Integer> arr = new ArrayList<>();
        while(!q.isEmpty())
        {
            int n = q.size();
            for(int i = 0 ; i < n ;i++)
            {
                TreeNode temp = q.poll();
                arr.add(temp.val);
                if(temp.left != null) q.offer(temp.left);
                if(temp.right != null) q.offer(temp.right);
            }
        }
        for(int i = 0 ; i < arr.size() ;i++)
        {
            if(i == 0) System.out.print(arr.get(i));
            else System.out.print(" " + arr.get(i));
        }
    }

    private static TreeNode BuilderTree(int left, int right) {
        if(left > right) return null;
        int num = postorder[post_index];
        post_index --;
        TreeNode root = new TreeNode(num);
        int index = map.get(num);
        root.right = BuilderTree(index + 1,right);
        root.left = BuilderTree(left ,index - 1);
        return root;
    }
}
class TreeNode{
    int val;
    TreeNode left,right;
    public TreeNode()
    {

    }
    public TreeNode(int num)
    {
        this.val = num;
    }
}