已知前序遍历序列和中序遍历序列，求二叉树的后序遍历

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/Liuhe_5656/article/details/52471434

本文只作为学习笔记，如若侵权请告知，一定及时删除

题目

已知前序遍历序列和中序遍历序列，求二叉树的后序遍历

思路：

在前序遍历的序列中第一个就是树的根结点，此时再在中序遍历的序列里查找这个根结点，则中序遍历的序列里根结点左侧的就是左子树，右侧的就是右子树，再对左右子树进行同样的操作，此时可以使用递归实现，这样便能构造出这个二叉树。

代码

class TreeNode{

    private int value;
    private TreeNode left;
    private TreeNode right;

    public TreeNode(int value) {
        super();
        this.value = value;
    }

    public TreeNode(int value, TreeNode left, TreeNode right) {
        super();
        this.value = value;
        this.left = left;
        this.right = right;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public TreeNode1 getLeft() {
        return left;
    }

    public void setLeft(TreeNode left) {
        this.left = left;
    }

    public TreeNode1 getRight() {
        return right;
    }

    public void setRight(TreeNode right) {
        this.right = right;
    }

}

public class Item {

    public static void main(String[] args) {

        // 二叉树的前序遍历  
        int preOrder[] = { 1, 2, 4, 7, 3, 5, 6, 8 };  
        // 二叉树的中序遍历  
        int inOrder[] = { 4, 7, 2, 1, 5, 3, 8, 6 }; 

        TreeNode root = constructTree(preOrder, inOrder);
        printPostOrder(root);

    }

    //重建二叉树
    private static TreeNode1 constructTree(int preOrder[], int inOrder[]){

        //根据前序遍历创建根节点
        TreeNode root = new TreeNode(preOrder[0]);
        root.setLeft(null);
        root.setRight(null);

        //左子树的个数
        int leftNum = 0;

        //在中序遍历中找到根节点并得出左子树的个数
        for (int i = 0; i < inOrder.length; i++) {
            if (inOrder[i] == root.getValue()) {
                break;
            }
            leftNum++;
        }

        //右子树的个数
        int rightNum = inOrder.length - leftNum - 1;

        if (leftNum > 0) {
            //构造左子树的前序遍历和中序遍历
            int leftPreOrder[] = new int[leftNum];
            int leftInOrder[] = new int[leftNum];

            for (int i = 0; i < leftInOrder.length; i++) {
                leftPreOrder[i] = preOrder[1 + i];
                leftInOrder[i] = inOrder[i];
            }

            //递归构建左子树
            TreeNode leftRoot = constructTree(leftPreOrder, leftInOrder);
            root.setLeft(leftRoot);

        }

        if (rightNum > 0) {
            //构造右子树的前序遍历和中序遍历
            int rightPreOrder[] = new int[rightNum];
            int rightInOrder[] = new int[rightNum];

            for (int i = 0; i < rightInOrder.length; i++) {
                rightPreOrder[i] = preOrder[leftNum + 1 + i];
                rightInOrder[i] = preOrder[leftNum + 1 + i];
            }

            //递归构建右子树
            TreeNode rightRoot = constructTree(rightPreOrder, rightInOrder);
            root.setRight(rightRoot);
        }
        return root;
    }

    //二叉树的后序遍历
    public static void printPostOrder(TreeNode root){

        if (root != null) {
            printPostOrder(root.getLeft());
            printPostOrder(root.getRight());
            System.out.printf(root.getValue() + "  ");
        }
    }
}

感谢

谢谢一个博主的分享，在此学习以作记录。
博主地址：http://my.csdn.net/google19890102