【蓝桥杯算法】给出二叉树前序遍历，中序遍历，输出后序遍历

一、问题描述

最近，WYF正准备参观他的点卡工厂。WYF集团的经理氰垃圾需要帮助WYF设计参“观”路线。现在，氰垃圾知道一下几件事情:
（1）WYF的点卡工厂构成一颗二叉树。
（2）—共有n座工厂。
（3）.他需要把这颗树上的点以后序遍历的方法列出来，才能绘制地图。
还好，最近他的属下给了他先序遍历和中序遍历的数据。可是，氰垃圾最近还要帮愈潭宇解决一些问题，没有时间。请你帮帮他，替他完成这项任务。由于氰垃圾的一些特殊的要求，WYF的参观路线将会是这棵树的后序遍历。

---

二、问题分析

解题思路：先序遍历序列的第一个字符为根结点。对于中序遍历，根结点在中序遍历序列的中间，左边部分是根结点的左子树的中序遍历序列，右边部分是根结点的右子树的中序遍历序列。

---

三、算法实现

Node类：

public class Node {
    public int data;
    public Node left;
    public Node right;

    public Node() {
    }
    public Node(int data) {
        this.data = data;
        this.left=null;
        this.left=null;
    }
}

Tree类：

public class Tree {
    private Node root;
    //构造器
    public Tree() {
            root=null;
        }

    /**
     * //后序遍历
     * @param localRoot
     */
    public void sendOrder(Node localRoot){
            if(localRoot!=null){
                sendOrder(localRoot.left);
                sendOrder(localRoot.right);
                System.out.print(localRoot.data+" ");
            }
        }
        public void sendOrder(){
            this.sendOrder(this.root);
        }
        public void startTree(int[] boforeOrder, int []inOrder){
            this.root=this.startTree(boforeOrder, 0, boforeOrder.length-1,inOrder,0,inOrder.length);
        }
        public Node startTree(int[] beforeOrder, int bStart, int bEnd, int[] inOrder, int inStart,
                              int inEnd) {
            if(bStart > bEnd || inStart > inEnd){
                return null;
            }
            int root = beforeOrder[bStart];
            Node head=new Node(root);

            //根节点所在的位置
            int rootIndex= searchIndex(inOrder, root, inStart, inEnd);
            //左子树个数
            int sum =rootIndex- inStart -1;
            //构建左子树
            head.left= startTree(beforeOrder, bStart +1, bStart +1+ sum,inOrder, inStart, inStart + sum);
            //构建右子树
            head.right= startTree(beforeOrder, bStart +2+ sum, bEnd,inOrder,rootIndex+1, inEnd);

            return head;
        }

        public int searchIndex(int[] inOrder, int root, int statrt,
                               int end) {
            for (int i = statrt; i <= end; i++) {
                if(inOrder[i]==root){
                    return i;
                }
            }
            return -1;
        }

    }

Main类：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Tree tree=new Tree();

        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入工厂数：");
        int n=scanner.nextInt();
        int[] beforeTree= new int[n];
        int[] inTree =new int[n];
        System.out.println("先序遍历：");
        for(int i=0;i<n;i++){
            beforeTree[i]=scanner.nextInt();
        }
        System.out.println("中序遍历：");
        for(int i=0;i<n;i++){
            inTree[i]=scanner.nextInt();
        }

        tree.startTree(beforeTree, inTree);
        System.out.println("二叉树的后序遍历：");
        tree.sendOrder();


    }
}

---

测试
1、测试用例：n=8
先序遍历：1 2 4 5 7 3 6 8
中序遍历：4 2 7 5 1 8 6 3
测试结果：
后序遍历：4 7 5 2 8 6 3 1

2、测试用例：n=6
先序遍历：4 2 6 3 1 5
中序遍历：6 2 3 4 1 5
测试结果：
后序遍历：6 3 2 5 1 4