PTA 树的遍历 (25 分) Java（根据中序遍历和后序遍历构建二叉树)&（二叉树层序遍历）

L2-006 树的遍历 (25 分)

给定一棵二叉树的后序遍历和中序遍历，请你输出其层序遍历的序列。这里假设键值都是互不相等的正整数。

输入格式：

输入第一行给出一个正整数N（≤30），是二叉树中结点的个数。第二行给出其后序遍历序列。第三行给出其中序遍历序列。数字间以空格分隔。

输出格式：

在一行中输出该树的层序遍历的序列。数字间以1个空格分隔，行首尾不得有多余空格。

输入样例：

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

输出样例：

4 1 6 3 5 7 2

后序中序构建二叉树 思路：

1.可以根据后序遍历-->根节点

2.根据中序遍历-->根节点的下标

3.根据根节点下标来分别分切出左右子数的中序和前序

4.递归重复，知道后序序列的数组长度为0，则停止

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

public class Main {
	static String s1 = "";
	static ArrayList<TreeNode> queue = new ArrayList<>();
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int[] postorder  = new int[n];
        int[] inorder = new int[n];
        for(int i = 0;i<n;i++) {
        	postorder[i] = scan.nextInt();
        }
        for(int i = 0;i<n;i++) {
        	inorder[i] = scan.nextInt();
        }
        TreeNode root = buildTree(postorder,inorder); //构建树
        traverseTreeByfloor(root);  //层序遍历二叉树
    }
    
    private static TreeNode buildTree(int[] postorder, int[] inorder) {
    	if(postorder.length==0)
    		return null;
    	
    	//由后序可知道子树跟根结点
    	TreeNode root = new TreeNode(postorder[postorder.length-1]); 
    	//由中序可以知道子树根结点的下标
    	int rootIndex = findRootIndex(inorder,postorder[postorder.length-1]);
    	
    	//切割出左子树的中序 和 后序 数组
    	int[] leftIn = Arrays.copyOfRange(inorder, 0, rootIndex); //中序
    	int[] leftPost = Arrays.copyOfRange(postorder, 0, rootIndex); //后序
    	root.left = buildTree(leftPost, leftIn);
    	
    	//切割出右子树的中序 和 后序 数组
    	int[] rightIn = Arrays.copyOfRange(inorder,rootIndex+1,postorder.length); //中序
    	int[] rightPost = Arrays.copyOfRange(postorder, rootIndex, postorder.length-1); //后序
    	root.right = buildTree(rightPost, rightIn);
    	
		return root;
	}

    
	private static int findRootIndex(int[] inorder,int rootVal) {
		for(int i = 0;i<inorder.length;i++) {
			if(inorder[i] == rootVal)
				return i;
		}
		return -1;
	}

    //层序遍历 --> BFS算法 & 队列
    private static void traverseTreeByfloor(TreeNode tree) {
    	queue.add(tree);
    	while(true) {
    		if(queue.size() == 0)
    			break;
    		bfsTree(queue.get(0));  
    		s1 += queue.get(0).val + " ";
    		queue.remove(0); //出队列
    	}
        //截取掉最后结尾的“ ”，输出结果
    	System.out.println(s1.substring(0, s1.length()-1));
    }

    //获取相邻的两个结点
	private static void bfsTree(TreeNode tree) {
		if(tree.left!=null)
			queue.add(tree.left);
		if(tree.right!=null)
			queue.add(tree.right);
	}
    

}
class TreeNode {
   int val;
   TreeNode left;
   TreeNode right;
    
   TreeNode(int x) {
       val = x;
   }
}