根据遍历结果，构造二叉树

1. 根据前序遍历和中序遍历构造二叉树

/*函数1：函数返回构造的二叉树，同时输出后序遍历结果。*/
TNode* BinaryTreeFromOrderings(int* inorder, int* preorder, int length)
{
    TNode* node ;
  if(length == 0)
    {
      return NULL;
    }
 // TNode* node = new TreeNode;//Noice that [new] should be written out.
  node =(TNode*)malloc(sizeof(TNode));
  node->value = *preorder;
  int rootIndex = 0;
  for(;rootIndex < length; rootIndex++)//a variation of the loop
    {
      if(inorder[rootIndex] == *preorder)
      break;
    }
  node->lchild = BinaryTreeFromOrderings(inorder, preorder +1, rootIndex);
  node->rchild = BinaryTreeFromOrderings(inorder + rootIndex + 1, preorder + rootIndex + 1, length - (rootIndex + 1));
  std::cout<<node->value<<std::endl;
  return node;
}

//函数2：根据先序遍历、中序遍历构建二叉树
BTree rebuild(int preOrder[],int startPre,int endPre,int inOrder[],int startIn,int endIn)
{
    //先序遍历和中序遍历长度应相等
    if (endPre - startPre != endIn - startIn) return NULL;
    //起始位置不应大于末尾位置
    if (startPre > endPre) return NULL;
    //先序遍历的第一个元素为根节点
    BTree tree = (BTree)malloc(sizeof(TNode));
    tree->value = preOrder[startPre];
    tree->lchild = NULL;
    tree->rchild = NULL;
    //先序遍历和中序遍历只有一个元素时，返回该节点
    if (startPre == endPre) return tree;
    //在中序遍历中找到根节点
    int index,length;
    for (index=startIn;index<=endIn;index++)
    {
        if (inOrder[index] == preOrder[startPre]) break;
    }
    //若未找到，返回空
    if (index > endIn) return NULL;
    //有左子树，递归调用构建左子树
    if (index > startIn)
    {
        length = index-startIn;
        tree->lchild = rebuild(preOrder,startPre+1,startPre+1+length-1,inOrder,startIn,startIn+length-1);
    }
    //有右子树，递归调用构建右子树
    if (index < endIn)
    {
        length = endIn - index;
        tree->rchild = rebuild(preOrder,endPre-length+1,endPre,inOrder,endIn-length+1,endIn);
    }
    return tree;
}

2.根据后序遍历和中序遍历构造二叉树

/*函数返回构造的二叉树，同时输出前序遍历结果。*/
TNode* BiTreeIn_PostOrder(int* inorder, int* postorder, int length)
{
    TNode* node ;
  if(length == 0)
    {
      return NULL;
    }
 // TNode* node = new TreeNode;//Noice that [new] should be written out.
  node =(TNode*)malloc(sizeof(TNode));
  node->value = *(postorder+length-1);
  std::cout<<node->value<<std::endl;

  int rootIndex = 0;
  for(;rootIndex < length; rootIndex++)//a variation of the loop
    {
      if(inorder[rootIndex] == *(postorder+length-1))
      break;
    }
  node->lchild = BiTreeIn_PostOrder(inorder, postorder, rootIndex);
  node->rchild = BiTreeIn_PostOrder(inorder + rootIndex + 1, postorder + rootIndex , length - (rootIndex + 1));

  return node;
}

3.验证程序

#include <stdlib.h>
#include <stdio.h>
#include <iostream>
#include <fstream>
#include <string>

/*定义*/
typedef struct TNode
{
    int value;
    TNode* lchild;
    TNode* rchild;
}TNode,*BTree;


/*后序递归遍历二叉树*/
void postTraverse(BTree tree)
{
    if (tree->lchild != NULL) postTraverse(tree->lchild);
    if (tree->rchild != NULL) postTraverse(tree->rchild);
    printf("%d ",tree->value);
}
/*前序递归遍历二叉树*/
void preTraverse(BTree tree)
{
    printf("%d ",tree->value);
    if (tree->lchild != NULL) preTraverse(tree->lchild);
    if (tree->rchild != NULL) preTraverse(tree->rchild);

}
/*main  */

int main()
{
    int preOrder[] = {1,2,4,5,3,6};
    int inOrder[] = {4,2,5,1,6,3};
    int postOrder[]={4,5,2,6,3,1};
    BTree tree = rebuild(preOrder,0,5,inOrder,0,5);
    postTraverse(tree);
    printf("\n");

    BTree node = BinaryTreeFromOrderings(inOrder, preOrder, 6);
    postTraverse(node);
    printf("\n");

   BTree Node= BiTreeIn_PostOrder(inOrder, postOrder, 6);
   preTraverse(Node);

    return 0;
}

引用：

http://blog.csdn.net/feliciafay/article/details/6816871
http://www.cr173.com/html/18891_1.html
http://canlynet.blog.163.com/blog/static/255013652009112602449178/
http://blog.csdn.net/sgbfblog/article/details/7783935
http://blog.csdn.net/zhaojinjia/article/details/9314989
http://blog.csdn.net/lxqfirst/article/details/7984611