重建二叉树

题目

给出某二叉树的前序遍历和中序遍历结果（或者中序遍历和后序遍历结果），重建二叉树。

分析

前序遍历：先根节点，然后左子树、右子树

中序遍历：中间根节点，先左子树，最后右子树

后序遍历：最后根节点，先左子树，然后右子树

根据前序遍历和中序遍历重构二叉树：
根据前序遍历序列，第一个元素为根节点。然后观察中序遍历结果，根节点左边的为左子树，右边的为右子树。递归查找即可重构二叉树。
根据中序遍历和后序遍历重构二叉树：
后序遍历的最后一个元素为根节点，依次递归查找，同上。
根据前序遍历和后序遍历重构二叉树：
由于未知左右子树的具体位置，所以重构的二叉树不唯一。

 根据此二叉树和变化思路来重构二叉树

根据前序遍历和中序遍历构建二叉树

import java.util.HashMap;

public class Solution {
	public static void main(String[] args) {

		int[] preOrder = {1, 2, 4, 5, 8, 3, 6, 7};
		int[] midOrder = {4, 2, 8, 5, 1, 6, 3, 7};
		int[] lastOrder = {4, 8, 5, 2, 6, 7, 3, 1};
		
		//利用前序、中序遍历重建二叉树
		Node root = rebuildBinTree(preOrder, midOrder);
		getLastOrder(root);
	}
	
	/**
	 * 利用前序、中序遍历重建二叉树
	 * @param preOrder
	 * @param midOrder
	 * @return
	 */
	private static Node rebuildBinTree(int[] preOrder, int[] midOrder) {
		if(preOrder == null || midOrder == null)
			return null;
		//保存中序遍历中每个数的下标（便于左右子树范围的定位）
		HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
		for(int i=0; i<midOrder.length; i++) {
			map.put(midOrder[i], i);
		}
		
		Node root = getRoot(preOrder, 0, preOrder.length-1, 
				midOrder, 0, midOrder.length-1, map);
		return root;
	}

	private static Node getRoot(int[] preOrder, int pi, int pj, 
			int[] midOrder, int mi, int mj,
			HashMap<Integer, Integer> map) {
		if(pi > pj)
			return null;
		Node root = new Node(preOrder[pi]);
		int index = map.get(preOrder[pi]);//获取当前节点所在中序遍历的位置
		// index - mi 表示此子树含有的节点数，再加 pi 表示在前序序列中的绝对位置
		root.lchild = getRoot(preOrder, pi+1, index-mi+pi,
				midOrder, mi, index-1, map);
		root.rchild = getRoot(preOrder, index-mi+pi+1, pj,
				midOrder, index+1, mj, map);
		return root;
	}

	private static void getLastOrder(Node node) {
		if(node != null) {
			getLastOrder(node.lchild);
			getLastOrder(node.rchild);
			System.out.print(node.val + " ");
		}
	}

	static class Node{
		int val;
		Node lchild;
		Node rchild;
		public Node(int val) {
			super();
			this.val = val;
			this.lchild = null;
			this.rchild = null;
		}
	}

}

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

import java.util.HashMap;

public class Solution {
	public static void main(String[] args) {

		int[] preOrder = {1, 2, 4, 5, 8, 3, 6, 7};
		int[] midOrder = {4, 2, 8, 5, 1, 6, 3, 7};
		int[] lastOrder = {4, 8, 5, 2, 6, 7, 3, 1};
		
		//利用中序、后序遍历重建二叉树
		Node root = rebuildBinTree(midOrder, lastOrder);
		getPreOrder(root);
	}
	
	/**
	 * 利用中序、后序遍历重建二叉树
	 * @param preOrder
	 * @param midOrder
	 * @return
	 */
	private static Node rebuildBinTree(int[] midOrder, int[] lastOrder) {
		if(midOrder == null || lastOrder == null)
			return null;
		HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
		for(int i=0; i<midOrder.length; i++) {
			map.put(midOrder[i], i);
		}
		Node root = getRoot(midOrder, 0, midOrder.length-1,
				lastOrder, 0, lastOrder.length-1, map);
		return root;
	}

	private static Node getRoot(int[] midOrder, int mi, int mj,
			int[] lastOrder, int li, int lj,
			HashMap<Integer, Integer> map) {
		if(li > lj || lj >= lastOrder.length)
			return null;
		Node root = new Node(lastOrder[lj]);
		int index = map.get(lastOrder[lj]);
		// index - mi 表示此子树含有的节点数，再加 li 表示在后序序列中的绝对位置
		// 相对于上个例子多减了 1 ，因为后序是从后开始找的，而前序是从前开始找的
		root.lchild = getRoot(midOrder, mi, index-1,
				lastOrder, li, index-mi+li-1,map);
		root.rchild = getRoot(midOrder, index+1, mj,
				lastOrder, index-mi+li, lj-1, map);
		return root;
	}

	private static void getPreOrder(Node node) {
		if(node != null) {
			System.out.print(node.val + " ");
			getPreOrder(node.lchild);
			getPreOrder(node.rchild);
		}
	}

	static class Node{
		int val;
		Node lchild;
		Node rchild;
		public Node(int val) {
			super();
			this.val = val;
			this.lchild = null;
			this.rchild = null;
		}
	}

}

---

如有错误或不合理的地方，敬请指正~
加油！！