重建二叉树

【题目】根据二叉树的前序和中序遍历，重建二叉树，返回根节点。

1. 根据前序遍历，找到根节点。

2. 在中序遍历中找到根节点的位置，进而得到中序遍历中左右两个子树的划分位置。

3. 在前序遍历中找到左右两个子树的位置。

4. 根据这些位置，对左右子树分别进行递归操作，得到根节点的左右孩子节点。

public class Main {

    public static void main(String[] args) throws Exception {

        int[] pre = { 1, 2, 4, 7, 3, 5, 6, 8 };
        int[] mid = { 4, 7, 2, 1, 5, 3, 8, 6 };

        Main main = new Main();
        Node root = main.process(pre, mid, 8);

        // 验证：前序遍历
        main.pre(root);

        System.out.println();

        // 验证：中序遍历
        main.mid(root);

        System.out.println();

        // 验证：后序遍历
        main.back(root);
    }

    public Node process(int[] pre, int[] mid, int length) throws Exception {

        if (null == pre || null == mid || length <= 0) {
            return null;
        }

        return buildTree(0, pre.length - 1, 0, mid.length - 1, pre, mid);
    }

    public Node buildTree(int startPre, int endPre, int startMid, int endMid,
            int[] pre, int[] mid) throws Exception {

        // 得到前序遍历第一个节点--根节点
        int rootValue = pre[startPre];
        Node rootNode = new Node(rootValue, null, null);

        if (startPre == endPre) {
            if (startMid == endMid && pre[startPre] == mid[startMid]) {
                return rootNode;
            } else {
                throw new Exception("invalid input");
            }
        }

        // 在中序遍历中找到根节点的位置
        int rootIndex = startMid;
        while (rootIndex <= endMid && mid[rootIndex] != rootValue) {
            rootIndex++;
        }
        if (rootIndex == endMid && mid[rootIndex] != rootValue) {
            throw new Exception("invalid input");
        }

        int leftLength = rootIndex - startMid;
        int preLeftEnd = startPre + leftLength;

        // 递归构建左子树
        if (leftLength > 0) {
            rootNode.setLeft(buildTree(startPre + 1, preLeftEnd, startMid,
                    rootIndex - 1, pre, mid));
        }

        // 递归构建右子树
        if (leftLength < endPre - startPre) {
            rootNode.setRight(buildTree(preLeftEnd + 1, endPre, rootIndex + 1,
                    endMid, pre, mid));
        }

        return rootNode;
    }

    public void pre(Node root) {

        if (null != root) {
            System.out.print(root.getValue() + " ");
        }

        if (null != root.getLeft()) {
            pre(root.getLeft());
        }

        if (null != root.getRight()) {
            pre(root.getRight());
        }
    }

    public void mid(Node root) {

        if (null != root.getLeft()) {
            mid(root.getLeft());
        }

        if (null != root) {
            System.out.print(root.getValue() + " ");
        }

        if (null != root.getRight()) {
            mid(root.getRight());
        }
    }

    public void back(Node root) {

        if (null != root.getLeft()) {
            back(root.getLeft());
        }

        if (null != root.getRight()) {
            back(root.getRight());
        }

        if (null != root) {
            System.out.print(root.getValue() + " ");
        }
    }
}

class Node {
    private int value;
    private Node left;
    private Node right;

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

    public int getValue() {
        return value;
    }

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

    public Node getLeft() {
        return left;
    }

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

    public Node getRight() {
        return right;
    }

}