通过前序遍历和中序遍历重建二叉树以及输出后序遍历（Java实现）

题目是通过前序遍历和中序遍历重建二叉树以及输出后序遍历

主要的难点在二叉树的重建，测试用例为前序遍历为{1,2,4,7,3,5,6,8}，中序遍历为：{4,7,2,1,5,3,8,6}。由前序遍历可以看出根节点是1，由中序遍历1的位置可以知道4 7 2 是左子树，5 3 8 6 是右子树，再将4 7 2看成一棵树继续用此方法，可见递归可容易实现。

值得注意的是：这里没有使用类将节点表示，而是使用一个数组表示一颗二叉树，这样虽然效率稍高，但实现起来远不如用类方便，下一篇将介绍使用类实现的重建树。

代码实现和结果为：

代码实现了树的重建 public int [] rebuildTree(int[] qx, int[] zx)，以及前序遍历，后序遍历和中序遍历的方法，并且前序遍历使用了两种方法。

/*
 * 给定前序遍历和中序遍历，重建树并输出后序遍历
 */
package sh.tree;

import java.util.ArrayList;
import java.util.Stack;

public class RebuildTree {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int [] qx = {1,2,4,7,3,5,6,8};
		int [] zx = {4,7,2,1,5,3,8,6};
		RebuildTree rt = new RebuildTree();
		int [] tree = rt.rebuildTree(qx, zx);
		rt.printTree(tree);
		rt.hxbl(tree);
		rt.qxbl(tree);
		rt.zxbl(tree);
	}
	//输出树
	private void printTree(int[] tree) {
		// TODO Auto-generated method stub
		
		for(int i=0;i<tree.length;i++)
			System.out.print(tree[i]+" ");
		System.out.println();
	}

	public void qxbl(int tree[]) {// 前序遍历
		ArrayList<Integer> al = new ArrayList<Integer>();
		Stack<Integer> stack = new Stack<Integer>();
		al = qxbl(tree, 1, al);
		stack = qxbl(tree, 1, stack);
		System.out.print("前序遍历结果是:");
		for(int i : al)
			System.out.print(i+" ");
		System.out.println();
		System.out.print("前序遍历结果2是:");
		while(!stack.isEmpty())
			System.out.print(stack.pop() + " ");
		System.out.println();		
				
	}

	public ArrayList<Integer> qxbl(int tree[],int root,ArrayList<Integer> al)
	{
		//当前根节点存放在队列ArrayList中，当没有子节点时，返回队列即为前序遍历
		if(tree[root] == 0)
			return null;
		al.add(tree[root]);
		if(tree[root*2] != 0)
			qxbl(tree,2*root,al);
		if(tree[root*2+1] != 0)
			qxbl(tree,2*root+1,al);
		return al;
		
	}
	
	public Stack<Integer> qxbl(int tree[],int root,Stack<Integer> stack)
	{
		//该方法通过栈实现，主要是和中序以及后序遍历形成匹配，其实这里用队列是更简单的
		if(tree[root] == 0)
			return null;
		if(tree[root*2+1] != 0)
			qxbl(tree,2*root+1,stack);
		if(tree[root*2] != 0)
			qxbl(tree,2*root,stack);		
		stack.push(tree[root]);
		return stack;
		
	}
	public void zxbl(int tree[]) {// 中序遍历

		Stack<Integer> stack = new Stack<Integer>();
		int root = 1;
		stack =zxbl(tree, root, stack);
		System.out.print("中序遍历结果是:");
		while(!stack.isEmpty()){
			System.out.print(stack.pop()+" ");
		}
		System.out.println();
	}

	public Stack<Integer> zxbl(int tree[],int root,Stack<Integer> stack){
		if(tree[root] == 0)
			return null;
		//中序遍历首先将右孩子压入栈（如果有的话）,再将根节点压入栈，最后将左孩子压入栈
		if(tree[root*2+1] != 0);
			zxbl(tree,root*2+1,stack);
		
		stack.push(tree[root]);	
		
		if(tree[root*2] != 0)
			zxbl(tree,root*2,stack);
		
		return stack;
		
	}
	
	public void hxbl(int tree[]) {// 后序遍历
		
		Stack<Integer> stack = new Stack<Integer>();
		stack = hxbl(tree,1,stack);
		System.out.print("后序遍历结果是:");
		while(!stack.isEmpty())
			System.out.print(stack.pop()+" ");
		System.out.println();
		
	}

	public Stack<Integer> hxbl(int tree[],int root,Stack<Integer> stack)
	{
		//每次压入栈的都是当前的根节点，当前根节点没有子节点时，返回该栈，
		//注意栈的放入顺序是先右孩子再左孩子，这样输出的时候就是先左孩子再右孩子
		if(tree[root] == 0)
			return null;
		stack.push(tree[root]);
		if(tree[root*2+1] != 0){
			hxbl(tree,root*2+1,stack);
		}
		if(tree[root*2] != 0){
			hxbl(tree,root*2,stack);
		}	
		return stack;
	}
	
	// 重建树
	public int [] rebuildTree(int[] qx, int[] zx) {
		int len = qx.length;
		
		int[] tree = new int[(int) Math.pow(2, len-1)];

		this.build(tree, qx, zx, 1);
		return tree;
	}

	public int[] build(int[] tree,int[] qx,int[] zx,int rootIndex){
		int len = qx.length;
		if(qx.length == 1)
		{
			tree[rootIndex] = qx[0];
			return tree; 
		}
		else if(zx.length == 1)
		{
			tree[rootIndex] =zx[0];
			return tree;
		}
		
		int root = 0;
		if(qx.length>0)	
			root = qx[0];
		else if(zx.length > 0)
			root = zx[0];
		tree[rootIndex] = root;
		int i = 0;
		for(i=0;i<len;i++){
			if(root == zx[i])
				break;
		}
		//得到中序遍历中的左树数组
		int leftqx[] = new int [i];
		int rightqx[] = new int[len-1-i];
		int leftzx[] = new int [i];
		int rightzx[] = new int[len-1-i];
		for(int j=0;j<len;j++){
			//左边前序和右边前序赋值
			if(j < i)
				leftqx[j] = qx[j+1];
			else if(j<len-1)
				rightqx[j-i] = qx[j+1]; 			
			//左边中序和右边中序
			if(root != zx[j]){
				if(j < i)
					leftzx[j] = zx[j];
				else 
					rightzx[j-i-1] = zx[j];
			}			
		}
		if(leftqx.length > 0 || leftzx.length > 0)
			tree = this.build(tree, leftqx, leftzx, 2*rootIndex);
		if(rightqx.length > 0 || rightzx.length > 0)
			tree = this.build(tree, rightqx, rightzx, 2*rootIndex+1);
		
		return tree;
	}
}

结果为：

0 1 2 3 4 0 5 6 0 7 0 0 0 0 8 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
后序遍历结果是:7 4 2 5 8 6 3 1 
前序遍历结果是:1 2 4 7 3 5 6 8 
前序遍历结果2是:1 2 4 7 3 5 6 8 
中序遍历结果是:4 7 2 1 5 3 8 6 
第一行代表树，这里因为不知道树的深度，所以采取了最极端的例子，就是树全部在一侧成为链表的情况，也就是树的深度即为节点长度，通常情况下显然用不到这么多