二叉树前序后序中序互推总结

最近笔试题一直遇到这个题，今天就总结一下。本文主要回答以下几个问题（Java实现）：

1. 前序 + 中序 => 后序 + 层序
2. 后序 + 中序 => 前序 + 层序
3. 以上2个问题的2种解决办法（a. 手写出二叉树 b. 编程实现）

先看以下3种遍历的特点：

特点：

1. 前序的第一个是root，后序的最后一个是root。
2. 每种排序左子树右子树分布都是有规律的，见上图。
3. 对于每一个子树（左/右）可以看成一个全新的树，仍然遵循上面的规律。

根据上面的特点，可以解决问题（核心都是中序的结构特点：可以明确区分出左子树右子树的位置）：
前+中=>后+层：

1. 前序的第一个就是root，对应找到中序中根的位置，那么中序根前面的就是左子树，后面的就是右子树。
2. 数一下左子树右子树的元素个数，对应在前序中找到左子树右子树的位置，如上图标示。
3. 那么，下面对于左子树右子树又是一个全新的树，仍然按照以上规律，即在前序左子树L中，第一个元素B是root（同时也是父节点A的左节点），在前序右子树R中，第一个元素C是root（同时也是父节点A的右节点）……
4. 重建出二叉树之后，后序/层序就是遍历就OK了。

后+中=>前+层：（类似上面的方法，就是后序的根节点在尾部，相应的左子树/右子树的根节点B/C在尾部，见上图所示。）

具体解决办法：

1. 若是选择题，直接手写出二叉树，有了二叉树之后，什么序都秒秒钟的事。
2. 若是编程题，那就要动手实现了，具体有2个思路：a. 直接递归打印各种序的排列（不用重建二叉树）。 b. 先重建出二叉树，再各种序的遍历打印。

实现：

1. 手写：

   

2. 代码实现：

   直接递归打印，不用重建二叉树

   前序+中序=>后序

---

public class PreOrderAndInOrder {

    /**
     *
     * @param pre_bg_index 前序数组中，开始的索引（具体到左（右）子树中，数组开始索引+长度len精确指定了某一个左（右）子树）
     * @param in_bg_index 中序数组中，开始的索引
     * @param len 树（左（右）子树对应到数组中的长度）
     * @param pre_Order_Array 前序数组
     * @param in_Order_Array 中序数组 （这里一直把前序中序数组当做参数，是由于在递归过程中，没有动过数组，只是动态的去其中的某些项。）
     */
    public static void postOrderSolution(int pre_bg_index, int in_bg_index, int len, char[] pre_Order_Array, char[] in_Order_Array) {

        if (len == 0)
            return;

        char root = pre_Order_Array[pre_bg_index];
        if (len==1){//递归出口。
            System.out.print(root+" ");
            return;
        }

        int i = 0;
        while (root != in_Order_Array[in_bg_index + i]) {//找到中序根节点的位置。
            i++;
        }
        //左右中，标准的后序遍历的形式。
        postOrderSolution(pre_bg_index+1, in_bg_index, i, pre_Order_Array, in_Order_Array);
        postOrderSolution(pre_bg_index+i+1, in_bg_index+i+1, len-i-1, pre_Order_Array, in_Order_Array);
        System.out.print(root+" ");
    }

    public static void main(String[] args){

        char[] pre_Order_Array = {'A','B','D','E','H','C','F','G','I'};
        char[] in_Order_Array = {'D','B','H','E','A','F','C','G','I'};
        postOrderSolution(0, 0, pre_Order_Array.length, pre_Order_Array, in_Order_Array);
    }
}

---

后序+中序=>前序（与上面大体类似，就是后序的下标用于定位根节点的位置与前序不同）

---

public class InOrderAndPostOrder {

    /**
     *
     * @param post_end_index 后序数组中，结束的索引（具体到左（右）子树中，数组结束索引+长度len精确指定了某一个左（右）子树）
     * @param in_bg_index 中序数组中，开始的索引
     * @param len 树（左（右）子树对应到数组中的长度）
     * @param post_Order_Array 后序数组
     * @param in_Order_Array 中序数组 （这里一直把前序中序数组当做参数，是由于在递归过程中，没有动过数组，只是动态的去其中的某些项。）
     */
    public static void preOrderSolution(int post_end_index, int in_bg_index, int len, char[] post_Order_Array, char[] in_Order_Array) {

        if (len == 0)
            return;

        char root = post_Order_Array[post_end_index];
        if (len==1){//递归出口。
            System.out.print(root+" ");
            return;
        }

        int i = 0;
        while (root != in_Order_Array[in_bg_index + i]) {//找到中序根节点的位置。
            i++;
        }
        //中左右，标准的前序遍历的形式。注意左子树中后序结束的索引是从后往前减的，中间减掉的（len-i-1）是右子树对应的数组长度。
        System.out.print(root+" ");
        preOrderSolution(post_end_index-(len-i-1)-1, in_bg_index, i, post_Order_Array, in_Order_Array);
        preOrderSolution(post_end_index-1, in_bg_index+i+1, len-i-1, post_Order_Array, in_Order_Array);
    }

    public static void main(String[] args){

        char[] post_Order_Array = {'D','H','E','B','F','I','G','C','A'};
        char[] in_Order_Array = {'D','B','H','E','A','F','C','G','I'};
        preOrderSolution(post_Order_Array.length-1, 0, post_Order_Array.length, post_Order_Array, in_Order_Array);
    }
}

---

重建二叉树，然后各种序遍历输出，这里以 前序+中序=>后序+层序 为例：

---

public class TreeNode {

    char val;
    TreeNode left;
    TreeNode right;

    public TreeNode(char val) {
        this.val = val;
    }
}

---

public class ReConstructPreAndIn {
    /**
     * @param pre_bg_index    前序数组中，开始的索引（具体到左（右）子树中，数组开始索引+长度len精确指定了某一个左（右）子树）
     * @param in_bg_index     中序数组中，开始的索引
     * @param len             树（左（右）子树对应到数组中的长度）
     * @param pre_Order_Array 前序数组
     * @param in_Order_Array  中序数组 （这里一直把前序中序数组当做参数，是由于在递归过程中，没有动过数组，只是动态的去其中的某些项。）
     */
    public static TreeNode reConstruct(int pre_bg_index, int in_bg_index, int len, char[] pre_Order_Array, char[] in_Order_Array) {

        if (len == 0)
            return null;

        char root = pre_Order_Array[pre_bg_index];
        if (len == 1) {//递归出口。
            TreeNode newNode = new TreeNode(root);
            return newNode;
        }

        int i = 0;
        while (root != in_Order_Array[in_bg_index + i]) {//找到中序根节点的位置。
            i++;
        }
        TreeNode node = new TreeNode(root);
        node.left = reConstruct(pre_bg_index + 1, in_bg_index, i, pre_Order_Array, in_Order_Array);
        node.right = reConstruct(pre_bg_index + i + 1, in_bg_index + i + 1, len - i - 1, pre_Order_Array, in_Order_Array);
        return node;
    }

    //后序遍历
    public static void postOrderTransverse(TreeNode root) {
        if (root == null)
            return;

        if (root.left == null && root.right == null) {
            System.out.print(root.val + " ");
            return;
        }


        postOrderTransverse(root.left);
        postOrderTransverse(root.right);
        System.out.print(root.val + " ");
    }

    //层序遍历
    public static void levelOrderTransverse(TreeNode root){

        Queue queue = new LinkedList<>();
        queue.add(root);
        TreeNode node;
        while (!queue.isEmpty()){

            node = queue.peek();
            System.out.print(node.val+" ");
            queue.poll();
            if(node.left!=null)
                queue.add(node.left);
            if(node.right!=null)
                queue.add(node.right);
        }

    }

    public static void main(String[] args) {

        char[] pre_Order_Array = {'A', 'B', 'D', 'E', 'H', 'C', 'F', 'G', 'I'};
        char[] in_Order_Array = {'D', 'B', 'H', 'E', 'A', 'F', 'C', 'G', 'I'};
        TreeNode root = reConstruct(0, 0, pre_Order_Array.length, pre_Order_Array, in_Order_Array);
        postOrderTransverse(root);
        System.out.println();
        levelOrderTransverse(root);
    }
}

---

End