二叉树遍历、根据先序中序还原

package swordOffer;
//树的遍历
public class TraversalTree {

    //先序遍历 - 根左右
    public void preorderTraversal(TreeNode root) {
        if (root != null) {
            System.out.print(root.getData() + " ");
            preorderTraversal(root.getLeftChild());
            preorderTraversal(root.getRightChild());
        }
    }

    //中序遍历 - 左根右
    public void inorderTraversal(TreeNode root) {
        if (root != null) {
            inorderTraversal(root.getLeftChild());
            System.out.print(root.getData()+" ");
            inorderTraversal(root.getRightChild());
        }
    }

    //后序遍历 - 左右根
    public void postorderTraversal(TreeNode root) {
        if (root != null) {
            postorderTraversal(root.getLeftChild());
            postorderTraversal(root.getRightChild());
            System.out.print(root.getData()+" ");
        }
    }

    //根据先序遍历和中序遍历 还原二叉树
    public TreeNode creatTreeByPreorderAndInorder(int[] preOrder, int[] inOrder, int preStart, int preEnd, int inStart, int inEnd) {
        if (preOrder.length == 0 || inOrder.length == 0) {
            return null;
        }
        TreeNode root = new TreeNode(preOrder[preStart]);  //先序遍历第一个节点为根节点
        if (preStart == preEnd) {
            return root;
        }
        //拆分左右子树
        int i = inStart;
        while (i < inEnd) {
            if (inOrder[i] == preOrder[preStart]) {
                break;
            }
            i++;
        }
        int leftLength = i - inStart;
        int rightLength = inEnd - i;
        if (leftLength > 0) {
            root.setLeftChild( creatTreeByPreorderAndInorder(preOrder, inOrder, preStart + 1, preStart + leftLength, inStart, i - 1) );
        }
        if (rightLength > 0) {
            root.setRightChild( creatTreeByPreorderAndInorder(preOrder, inOrder, preStart + leftLength + 1, preEnd, i + 1, inEnd) );
        }
        return root;
    }
    //构造一棵树
    /*
     *           1
     *        2     3
     *      4      5  6
     *        7    8 
     */
    public TreeNode<Integer> creatTree() {
        TreeNode<Integer> root = new TreeNode(1);
        root.setLeftChild(new TreeNode(2));
        root.setRightChild(new TreeNode(3));
        root.getLeftChild().setLeftChild(new TreeNode(4));
        root.getLeftChild().getLeftChild().setRightChild(new TreeNode(7));
        root.getRightChild().setLeftChild(new TreeNode(5));
        root.getRightChild().setRightChild(new TreeNode(6));
        root.getRightChild().getRightChild().setLeftChild(new TreeNode(8));
        return root;
    }

    public static void main(String[] args) {
        TraversalTree traversalTree = new TraversalTree();
        TreeNode root = traversalTree.creatTree();  //创建树
        System.out.println("先序遍历结果：");
        traversalTree.preorderTraversal(root);  //先序遍历
        System.out.println("");
        System.out.println("中序遍历结果：");
        traversalTree.inorderTraversal(root);  //中序遍历
        System.out.println("");
        System.out.println("后序遍历结果：");
        traversalTree.postorderTraversal(root);  //后序遍历

        //根据先序遍历和中序遍历 还原二叉树
        int[] preorder = {1,2,4,7,3,5,6,8};
        int[] inorder = {4,7,2,1,5,3,8,6};
        TreeNode creatTreeByPreAndIn = traversalTree.creatTreeByPreorderAndInorder(preorder, inorder, 0, 7, 0, 7);
        System.out.println("\r\n还原的二叉树的先序遍历结果：");
        traversalTree.preorderTraversal(creatTreeByPreAndIn);  //打印先序检测
    }
}

class TreeNode<T>{
    private T data;
    private TreeNode leftChild;
    private TreeNode rightChild;

    public TreeNode(T value) {
        this.data = value;
    }
    public T getData() {
        return data;
    }
    public void setData(T data) {
        this.data = data;
    }
    public TreeNode getLeftChild() {
        return leftChild;
    }
    public void setLeftChild(TreeNode leftChild) {
        this.leftChild = leftChild;
    }
    public TreeNode getRightChild() {
        return rightChild;
    }
    public void setRightChild(TreeNode rightChild) {
        this.rightChild = rightChild;
    }
}