二叉树的遍历与重构

先序遍历： 1,2,7,4,5,3,6,8
中序遍历：7,2,5,4,1,6,3,8
后序遍历：7,5,4,2,6,8,3,1

根据先序遍历和中序遍历重构二叉树

1. 先序遍历的第一个节点为根节点1
2. 在中序遍历中找到根节点1，其左侧的就是这个节点的左子树的中序遍历7,2,5,4，右侧的就是右子树的中序遍历6,3,8
3. 在先序遍历中找到左右子树的先序遍历2,7,4,5，3,6,8
4. 递归左右子树重构二叉树（左子树的先序遍历的第一个节点即为左子树的根节点…）

根据中序遍历和后序遍历重构二叉树

与前面差不多，后序遍历的最后一个节点为根节点，然后去中序遍历中找根节点的左右子树。
Tip: 中序遍历的根节点在中间，后序遍历的根节点在最后，取子树的遍历的时候能用到，如：
 第一次递归中，根节点1的在中序遍历中是第5个节点，那么其左子树就是左边4个（1 ～ 5-1），右子树为右3个（5+1 ～ 8）；左子树的后续遍历为前4个（1 ～ 5-1），右子树为连着的后面的3个（5~7）。

注意：根据先序遍历和后续遍历不能重构唯一的二叉树

package utils;

import java.util.Arrays;

class Node {
	int val;
	Node left;
	Node right;
	public Node() {}
	public Node(int val) {
		this.val = val;
	}
}

public class BinaryTree {
	// 先序遍历  根-左-右
	private static void firstOrder(Node root) {
		if (root ==null)return;
		System.out.print(root.val);
		firstOrder(root.left);
		firstOrder(root.right);
	}
	
	// 中序遍历  左-根-右
	private static void inOrder(Node root) {
		if (root ==null)return;
		inOrder(root.left);
		System.out.print(root.val);
		inOrder(root.right);
	}

	// 后序遍历  左-右-根
	private static void lastOrder(Node root) {
		if (root ==null)return;
		lastOrder(root.left);
		lastOrder(root.right);
		System.out.print(root.val);
	}
	
	// 根据先序遍历和后序遍历重构二叉树
    private static Node reConstructBinaryTree(int[] preOrder, int[] inOrder) {
        if (preOrder.length == 0 || inOrder.length == 0) {
            return null;
        }
        int len = preOrder.length;
        Node node = new Node(preOrder[0]);
        for (int i=0; i<len; i++) {
            if (preOrder[0] == inOrder[i]) {
                node.left = reConstructBinaryTree(
                        Arrays.copyOfRange(preOrder, 1, i+1),
                        Arrays.copyOfRange(inOrder, 0, i)
                );
                node.right = reConstructBinaryTree(
                        Arrays.copyOfRange(preOrder, i+1, len),
                        Arrays.copyOfRange(inOrder, i+1, len)
                );
            }
        }
        return node;
    }
	
	// 根据中序遍历和后续遍历重构二叉树
    private static Node reConstructBinaryTree2(int[] inOrder, int[] lastOrder) {
        if (lastOrder.length == 0 || inOrder.length == 0) {
            return null;
        }
        int len = lastOrder.length;
        Node node = new Node(lastOrder[len-1]);
        for (int i=0; i<len; i++) {
            if (lastOrder[len-1] == inOrder[i]) {
                node.left = reConstructBinaryTree2(
                        Arrays.copyOfRange(inOrder, 0, i),
                        Arrays.copyOfRange(lastOrder, 0, i)
                );
                node.right = reConstructBinaryTree2(
                        Arrays.copyOfRange(inOrder, i+1, inOrder.length),
                        Arrays.copyOfRange(lastOrder, i, lastOrder.length-1)
                );
            }
        }
        return node;
    }

    public static void main(String[] args) {
        int[] preOrder = {1,2,7,4,5,3,6,8};
        int[] inOrder = {7,2,5,4,1,6,3,8};
        int[] lastOrder = {7,5,4,2,6,8,3,1};
        Node root = reConstructBinaryTree(preOrder, inOrder);
        lastOrder(root);
        System.out.println();
        root = reConstructBinaryTree2(inOrder, lastOrder);
        firstOrder(root);
    }

}