通过前序遍历和中序遍历重建二叉树以及输出后序遍历（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

第一行代表树，这里因为不知道树的深度，所以采取了最极端的例子，就是树全部在一侧成为链表的情况，也就是树的深度即为节点长度，通常情况下显然用不到这么多