二叉树前序、中序和后序遍历相互求法

假设已知一个二叉树，其前序遍历为1,2,4,7,3,5,6,8；中序遍历为4,7,2,1,5,3,8,6;后序遍历为7, 4, 2, 5, 8, 6, 3, 1。
在已知前序遍历和中序遍历或者是中序遍历和后序遍历两者时，其二叉树顺序是确定的，即另一遍序方式是确定的。
在求解过程中，首先需要确定根节点（前序遍历的第一个点为根节点，后序遍历最后一个点为根节点），然后再在中序遍历中寻找根节点，故而确定左右子树，最后利用递归的方式即可得出结果。

#include <iostream>
#include <vector>
using namespace std;

struct TreeNode 
{
   int val;
   TreeNode *left;
   TreeNode *right;
   TreeNode(int x) : val(x), left(NULL), right(NULL) {}
}*TNode;

//已知前序和中序
struct TreeNode* reConstructBinaryTreePre(vector<int> pre, vector<int> in);
//已知中序和后序
struct TreeNode* reConstructBinaryTreePost(vector<int> in, vector<int> post);

void PostOrderTraverse(TreeNode *rt);
void PreOrderTraverse(TreeNode *rt);

int main()
{
int ppre[] = {1,2,4,7,3,5,6,8};
int iin[] = {4,7,2,1,5,3,8,6};
int ppos[] = {7, 4, 2, 5, 8, 6, 3, 1};

vector<int> pre;
vector<int> in;
vector<int> post;

for(int i = 0; i < 8; i++)
{
    pre.push_back(ppre[i]);
    in.push_back(iin[i]);
    post.push_back(ppos[i]);
}

cout << "后序遍历：" << endl;
TNode = reConstructBinaryTreePre(pre, in);
PostOrderTraverse(TNode);
cout << endl;

cout << "前序遍历：" << endl;
TNode = reConstructBinaryTreePost(in, post);
PreOrderTraverse(TNode);
cout << endl;

return 0;
}

//后序遍历
void PostOrderTraverse(TreeNode *rt)
{
if(rt != NULL)
{
    PostOrderTraverse(rt -> left);
    PostOrderTraverse(rt -> right);
    cout << rt -> val;
}
}

//前序遍历
void PreOrderTraverse(TreeNode *rt)
{
if(rt != NULL)
{
    cout << rt -> val;
    PreOrderTraverse(rt -> left);
    PreOrderTraverse(rt -> right);
}
}

//已知前序遍历和中序遍历，重建二叉树
struct TreeNode* reConstructBinaryTreePre(vector<int> pre,vector<int> in) 
{
    TreeNode* post = (TreeNode*)malloc(sizeof(struct TreeNode));

    int len = pre.size();
    if(len <= 0)
        return NULL;

    post -> val = pre[0];

    vector<int>::iterator iter = find(in.begin(), in.end(), pre[0]);

    vector<int> lpre(pre.begin() + 1, pre.begin() + (iter - in.begin()) + 1);
    vector<int> lin(in.begin(), iter);
    post -> left = reConstructBinaryTreePre(lpre, lin);

    vector<int> rpre(pre.begin() + (iter - in.begin()) + 1, pre.end());
    vector<int> rin(iter + 1, in.end());
    post -> right = reConstructBinaryTreePre(rpre, rin);

    return post;
}

//已知中序遍历和后序遍历，构建二叉树
struct TreeNode* reConstructBinaryTreePost(vector<int> in, vector<int> post)
{
TreeNode* pre = (TreeNode*)malloc(sizeof(struct TreeNode));

int len = in.size();
if(len <= 0)
    return NULL;

pre -> val = post[len - 1];

vector<int>::iterator iter = find(in.begin(), in.end(), post[len - 1]);

vector<int> lin(in.begin(), iter);
vector<int> lpost(post.begin(), post.begin() + (iter - in.begin()) + 1);
pre -> left = reConstructBinaryTreePost(lin, lpost);

vector<int> rin(iter + 1, in.end());
vector<int> rpost(post.begin() + (iter - in.begin()), post.end() - 1);
pre -> right = reConstructBinaryTreePost(rin, rpost);

return pre;
}