常考数据结构与算法:输出二叉树的右视图

题目描述

请根据二叉树的前序遍历，中序遍历恢复二叉树，并打印出二叉树的右视图

 

上图树的右视图为:{1,4,3,7} 

 

  做此题之前可以先做下面3道题:

    1. 常考数据结构与算法:求二叉树的层序遍历

    2.常考数据结构与算法:二叉树的之字形层序遍历

    3.常考数据结构与算法:重建二叉树

import java.util.ArrayList;
import java.util.Stack;

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

public class ReConstructBinaryTreeShowRight {
    public static void main(String[] args) {
            int[] xianxu = {1,2,8,4,5,6,7,3};
            int[] zhongxu = {8,2,1,5,7,6,4,3};

        ReConstructBinaryTreeShowRight reConstructBinaryTreeShowRight = new ReConstructBinaryTreeShowRight();
        reConstructBinaryTreeShowRight.solve(xianxu,zhongxu);
    }

    private TreeNode findBinaryTree(int[] xianxu,int preStart, int preEnd, int[] zhongxu, int inStart, int inEnd){
        if(preStart > preEnd || inStart > inEnd){
            return null;
        }

        TreeNode root = new TreeNode(xianxu[preStart]);
        for (int i = inStart; i <=inEnd ; i++) {
            if(xianxu[preStart] == zhongxu[i]){
                // 根节点
                /*
                   preStart+1,preStart+i-inStart 前序遍历的左子树
                   inStart,i-1 中序遍历的左子树
                */
                root.left = findBinaryTree(xianxu,preStart+1,preStart+i-inStart,zhongxu,inStart,i-1);

                 /*
                   preStart+1,preStart+i-inStart 前序遍历的右子树
                   inStart,i-1 中序遍历的右子树
                */
                root.right =findBinaryTree(xianxu,preStart+i-inStart+1,preEnd,zhongxu,i+1,inEnd);
            }
        }

        return root;
    }

    public int[] solve (int[] xianxu, int[] zhongxu) {
        TreeNode root = findBinaryTree(xianxu,0,xianxu.length-1, zhongxu,0, zhongxu.length-1);
        if(null == root){
            return null;
        }

        ArrayList<Integer> arrayList = new ArrayList<>();
        Stack<TreeNode> stack1 = new Stack<>();
        Stack<TreeNode> stack2 = new Stack<>();
        stack1.push(root);
        while(!stack1.isEmpty() || !stack2.isEmpty()){

            if(!stack1.isEmpty()){
                int len = stack1.size();
             while(!stack1.isEmpty()){
                 TreeNode node = stack1.pop();

                 if(node.right != null){
                     stack2.push(node.right);
                 }

                 if(node.left != null){
                     stack2.push(node.left);
                 }

                 if(len-1 == stack1.size()){
                     arrayList.add(node.val);
                 }
             }
            }else{
                while(!stack2.isEmpty()){
                    TreeNode node = stack2.pop();

                    if(node.left != null){
                        stack1.push(node.left);
                    }

                    if(node.right != null){
                        stack1.push(node.right);
                    }

                    if(stack2.size() == 0){
                        arrayList.add(node.val);
                    }
                }
            }
        }

        int[] arr = null;
        if(!arrayList.isEmpty()) {
            arr = new int[arrayList.size()];
            for (int i = 0; i < arrayList.size(); i++) {
                arr[i] = arrayList.get(i);
            }
        }

        return arr;
    }
}