典型的就是已知前序、中序求后序结果
######一般方法：
定义二叉树数据类型，然后通过前序、中序信息递归建立二叉树，然后后序访问输出结果
由于前序遍历的结果按顺序是根->左子树->右子树，所以用一个count变量记录当前设置的是前序第几个“根”节点

#include <iostream>
#include "stdio.h"

using namespace std;

/* 定义树节点数据类型 */
typedef struct node {
	char d;
	node *lchild,*rchild;
}*pTree,TreeNode;

int count; // 先序顺序计数

/* 从后序查找某节点位置并返回 */
int FindChar(char c, char *s2)
{
	for(int i = 0,j = strlen(s2); i<j; i++)
	{
		if(s2[i] == c) return i;
	}
	return 0;
}

/* 建立二叉树 */
void BuildBiTree(pTree &tree,char *s1, char *s2, int m, int n)
{
	if(m<=n)
	{
		tree = new TreeNode;
		tree->lchild = NULL;
		tree->rchild = NULL;
		tree->d = s1[count];
		int t = FindChar(s1[count],s2); // 查找左右子树分割位置
		count++; // 计数+1
		BuildBiTree(tree->lchild,s1,s2,m,t-1); // 递归左子树
		BuildBiTree(tree->rchild,s1,s2,t+1,n); // 递归右子树
	}
}

/* 后序遍历 */
void postOrder(pTree &tree)
{
	if(tree)
	{
		postOrder(tree->lchild);
		postOrder(tree->rchild);
		cout<<tree->d;
	}
}
int main()
{
	char s1[1000];
	char s2[1000];
	while(cin>>s1>>s2)
	{
		pTree tree;
		count = 0;
		BuildBiTree(tree,s1,s2,0,strlen(s1)-1);
		postOrder(tree);
	}
	return 0;
}

######直接求：
根据前序：根->左子树->右子树；中序：左子树->根->右子树；后序：左子树->右子树->根 来递归求出结果
根据后序遍历规则，最后才是根节点，所以count从最后一位开始，向前直到0，而且应该先递归 右子树，在递归 左子树
如下所示
前序 A BCEFD GH
中序 ECFBD A GH
后序结果：EFCDBHGA

第一遍设置了 _______A
——递归右子树-前序 GH 中序 GH
——设置G ______GA
————递归右子树-前序 H 后序 H
————设置H-_____HGA
——递归左子树-前序BCEFD 中序ECFBD
——设置B-____BHGA
————递归右子树-前序D 后序 D
————设置D-___DBHGA
————递归左子树-前序CEF 后序ECF
————设置C-__CDBHGA
——————递归左子树-前序F 后序 F
——————设置F-_FCDBHGA
——————递归右子树-前序E 后序 E
——————设置E-EFCDBHGA
输出结果：EFCDBHGA

#include <iostream>
#include "stdio.h"

using namespace std;

int count; // 后序"根"计数

/* 查找节点位置 */
int FindChar(char c, char *s2)
{
	for(int i = 0,j = strlen(s2); i<j; i++)
	{
		if(s2[i] == c) return i;
	}
	return 0;
}
/* 求后序结果 */
void BuildPostOrder(char *pre, char *in, char *post, int prem, int pren, int inm, int inn)
{
	if(prem<=pren && inm<=inn)
	{
		post[count--] = pre[prem];
		int t = FindChar(pre[prem],in);
		BuildPostOrder(pre,in,post,prem+1+t-inm,pren,t+1,inn); // 递归右子树
		BuildPostOrder(pre,in,post,prem+1,prem+t-inm,inm,t-1); // 递归左子树
	}
}
int main()
{
	char pre[1000];
	char in[1000];
	while(cin>>pre>>in)
	{
		char post[1000];
		memset(post,'\0',1000);
		count = strlen(pre)-1; // 从最后一位开始
		BuildPostOrder(pre,in,post,0,strlen(pre)-1,0,strlen(pre)-1);
		cout<<post<<endl;
	}
	return 0;
}

我的个人主页