浪漫侧影 Java

1.题目：

 

“侧影”就是从左侧或者右侧去观察物体所看到的内容。例如上图中男生的侧影是从他右侧看过去的样子，叫“右视图”；女生的侧影是从她左侧看过去的样子，叫“左视图”。

520 这个日子还在打比赛的你，也就抱着一棵二叉树左看看右看看了……

我们将二叉树的“侧影”定义为从一侧能看到的所有结点从上到下形成的序列。例如下图这棵二叉树，其右视图就是 { 1, 2, 3, 4, 5 }，左视图就是 { 1, 6, 7, 8, 5 }。

于是让我们首先通过一棵二叉树的中序遍历序列和后序遍历序列构建出一棵树，然后你要输出这棵树的左视图和右视图。

输入格式：

输入第一行给出一个正整数 N (≤20)，为树中的结点个数。随后在两行中先后给出树的中序遍历和后序遍历序列。树中所有键值都不相同，其数值大小无关紧要，都不超过 int 的范围。

输出格式：

第一行输出右视图，第二行输出左视图，格式如样例所示。

输入样例：

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

输出样例：

R: 1 2 3 4 5
L: 1 6 7 8 5

 2.思路分析：

第一步：我们先建立一颗树根据题目给的中序遍历和后续遍历可以知道。

第二步：建树的时候尤其要注意他们的关系，我是利用递归建立的。

第三步最重要的：由于题目是要侧影这种感觉所以不难发现我们就是要取层次遍历每层的第一个数和最后一个数，所以我么可以用java里面的queue来解决我采用的是递归。

3,

import java.util.*;
public class Main{
    static int n;
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        int[] inorder = new int[n];
        int[] postorder = new int[n];
        for (int i = 0; i < n; i++) {
            inorder[i] = in.nextInt();
        }
        for (int i = 0; i < n; i++) {
            postorder[i] = in.nextInt();
        }
        TreeNode root = creat(inorder,0,n,postorder,0,n);
        Queue<TreeNode> queue = new LinkedList<>();
        List<Integer> left = new ArrayList<>();
        List<Integer> right = new ArrayList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            int x = queue.size();
            for (int i = 0; i < x; i++) {
                TreeNode node = queue.poll();
                if(i == 0){
                    left.add(node.val);
                }
                if(i == x-1){
                    right.add(node.val);
                }
                if(node.left != null){
                    queue.add(node.left);
                }
                if(node.right != null){
                    queue.add(node.right);
                }
            }
        }
        System.out.print("R: ");
        for (int i = 0; i < right.size(); i++) {
            if(i == right.size()-1){
                System.out.print(right.get(i));
                break;
            }
            System.out.print(right.get(i)+" ");
        }
        System.out.println();
        System.out.print("L: ");
        for (int i = 0; i < left.size(); i++) {
            if(i == left.size()-1){
                System.out.println(left.get(i));
                break;
            }
            System.out.print(left.get(i)+" ");
        }
    }
    public static TreeNode creat(int[] inorder,int inleft, int inright, int[] postorder, int poleft,int poright){
        if(poright - poleft == 0){
            return null;
        }
        if(poright - poleft == 1){
            return new TreeNode(postorder[poright-1]);
        }
        TreeNode root = new TreeNode(postorder[poright-1]);
        int index = 0;
        int rootval = postorder[poright-1];
        for (int i = 0; i < inright; i++) {
            if(inorder[i] == rootval){
                index = i;
                break;
            }
        }
        TreeNode left = creat(inorder,inleft,index,postorder,poleft,index+poleft-inleft);
        TreeNode right = creat(inorder,index+1,inright,postorder,index+poleft-inleft,poright-1);
        root.left = left;
        root.right = right;
        return root;
    }
}
class TreeNode{
    int val;
    TreeNode left;
    TreeNode right;

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

4.运行结果：