二叉树的遍历和构建

一.先上图，一个简单的二叉树如下：

根据根节点的访问顺序，二叉树的遍历方式可分为三种：

1. 前序遍历：先访问根节点，再访问左子树，最后访问右子树
2. 中序遍历：先访问左子树，再访问根节点，最后访问右子树
3. 后序遍历：先访问左子树，再访问右子树，最后再访问根节点

上面二叉树的三种遍历序列分别如下：

1. 前序遍历序列：1,2,4,5,3,6
2. 中序遍历序列：4,2,5,1,6,3
3. 后续遍历序列：4,5,2,6,3,1

二.构建二叉树有两种方式：

1. 根据前序遍历序列和中序遍历序列构建
2. 根据中序遍历序列和后序遍历序列构建

构建思路：

对于方式1：前序遍历的第一个元素为根节点，在中序遍历序列中找到这个根节点，从而可以将中序遍历分为左右两部分，左边部分为左子树的遍历，右边部分为右子树的中序遍历，同样也可以把前序遍历序列除第一个元素之外的部分分为两个部分，第一个部分分为左子树的前序遍历，第二部分为右子树的前序遍历。由次可知，我们可以通过递归地调用构建函数，根据左子树、右子树的前序、中序遍历序列来构建左子树和右子树。

对于方式2：思路和方式1相似，不同的是在后序遍历序列中，最后一个元素为根节点

二叉树的构建可能会在以下场景用到：

1. 将一棵二叉树通过网络传输到另外一个客户端，然后在接收1的客户端恢复为二叉树。

     2. 把二叉树保存到文件中，然后再读取文件恢复二叉树

由上面的分析可以知道，要想重建二叉树，必须知道前序遍历序列+中序遍历序列或是后序遍历序列+中序遍历序列

代码实现（Java）：

public class BinaryTree {

    // 前序遍历序列{1,2,4,5,3,6}
    // 中序遍历序列{4,2,5,1,6,3}
    // 后续遍历序列{4,5,2,6,3,1}
    public static void main(String[] args) {
        int[] preOrder = {1,2,4,5,3,6};
        int[] inOrder = {4,2,5,1,6,3};
        int[] postOrder = {4,5,2,6,3,1};

        // 根据前序后序构建二叉树
        TreeNode root = buildPreAndInOrder(preOrder, 0, preOrder.length - 1,
                inOrder, 0, inOrder.length - 1);
        postOrderTraversal(root);

        System.out.println();

        // 根据中序后序构建二叉树
        root = buildPostAndInOrder(inOrder, 0, inOrder.length - 1,
                postOrder, 0, postOrder.length - 1);
        preOrderTraversal(root);
    }

    //根据前序和中序构建二叉树
    public static TreeNode buildPreAndInOrder(int[] preOrder, int startPre, int endPre,
                                              int[] inOrder, int startIn, int endIn) {
        if (startPre > endPre || startIn > endIn) {
            return null;
        }

        //前序遍历的第一个节点为跟节点
        TreeNode root = new TreeNode(preOrder[startPre]);

        //在中序遍历序列中查找根节点的位置
        for (int i = startIn; i <= endIn; i++) {
            if (preOrder[startPre] == inOrder[i]) {
                //根节点左边的为左子树
                root.left = buildPreAndInOrder(preOrder, startPre + 1, startPre + i - startIn,
                        inOrder, startIn, i - 1);
                //根节点右边的为右子树
                root.right = buildPreAndInOrder(preOrder, startPre + i - startIn + 1, endPre,
                        inOrder, i + 1, endIn);
            }
        }

        return root;
    }

    //根据中序和后序构建二叉树
    public static TreeNode buildPostAndInOrder(int[] inOrder, int startIn, int endIn,
                                               int[] postOrder, int startPost, int endPost) {
        if (startIn > endIn || startPost > endPost) {
            return null;
        }

        //后序遍历序列的最后一个节点为根节点
        TreeNode root = new TreeNode(postOrder[endPost]);

        //在中序遍历序列中查找根节点的位置
        for (int i = startIn; i <= endIn; i++) {
            if (inOrder[i] == postOrder[endPost]) {
                //根节点左边的为左子树
                root.left = buildPostAndInOrder(inOrder, startIn, i - 1,
                        postOrder, startPost, startPost + i - startIn - 1);
                //根节点右边的为右子树
                root.right = buildPostAndInOrder(inOrder, i + 1, endIn,
                        postOrder, startPost + i - startIn, endPost - 1);
            }
        }
        return root;
    }


    //前序遍历
    public static void preOrderTraversal(TreeNode root) {
        if (root == null) return;
        System.out.print(root.val + " ");
        preOrderTraversal(root.left);
        preOrderTraversal(root.right);
    }

    //中序遍历
    public static void inOrderTraversal(TreeNode root) {
        if (root == null) return;
        inOrderTraversal(root.left);
        System.out.print(root.val + " ");
        inOrderTraversal(root.right);
    }

    //后序遍历
    public static void postOrderTraversal(TreeNode root) {
        if (root == null) return;
        postOrderTraversal(root.left);
        postOrderTraversal(root.right);
        System.out.print(root.val + " ");
    }
}