由二叉树重建所引出的算法

前几天在sicily做到一道关于二叉树重建的问题，引出了许许多多的思考。

这道题的链接在：http://soj.me/1935 其实这道题不算太难，之前在数据结构课上，做过类似的，不过要将二叉树重建过来。

代码的实现如下：

#include <iostream>
#include <queue>
#include <string>
using namespace std;
template <typename T> struct BinaryNode{
  T elem;
  BinaryNode *left;
  BinaryNode * right;
  BinaryNode(T d, BinaryNode *l=NULL, BinaryNode *r=NULL):elem(d),left(l),right(r){};
};

BinaryNode<char>*  buildTree(const string &preorder, const string &inorder)
{
    BinaryNode<char> * root;
    string lp,li,rp,ri;
    int i,len,rlen;
    if(inorder.size() == 0 && preorder.size() ==0 ) 
        return NULL;
    len = preorder.size();
    char s = preorder[0];
    for(i = 0 ; i < len; i++)
    {
        if(inorder[i] == s)
            break;
    }
    rlen = len -1 -i;
    root = new BinaryNode<char>(s);
    lp = preorder.substr(1,i);
    li = inorder.substr(0,i);
    rp = preorder.substr(i+1,rlen); 
    ri = inorder.substr(i+1,rlen);
    root->left = buildTree(lp,li);
    root->right = buildTree(rp,ri);
    return root;
} 

void pro(BinaryNode<char> * root)
{
	if(root == NULL)
		;
	else
	{
		pro(root->left);
		pro(root->right);
		cout << root->elem ;
	}
}

int main()
{
	int n;
	cin >> n;
	while(n--)
	{
		string pre,in;
		cin >> pre >> in;
		BinaryNode<char> * root = buildTree(pre,in);
		level(root);
		cout << endl;
	}
	return 0;
}

 所以我在想：既然是用到递归的方法，能否不用建树的方法来完成这一道题呢？于是经过上网查阅资料，给我找到了这个算法。

关于这个算法，我真的不是很了解：之前并没有看过类似的算法，所以它到底是作者自创的呢？还是有一定的背景呢？

我不清楚。

这个算法大概如下：

Example：

ABDGCEF

DGBAECF

sample output：

GDBEFCA

用一个order数组存中序遍历中的字符在后序遍历中的顺序，从大到小。比如sample input中所得的order为：5 6 4 0 3 1 2。

直接用上面的例子说明算法过程：

order=0 0 0 0 0 0 0

对于str1中的A，找出它在str2中的位置为4，它左右order的值都和4位置的order的值相同，说明它有左、右子树

改变order的值为：

2 2 2 0 1 1 1

对于str1中的B，找出它在str2中的位置3，它左order的值和当前order值相同，说明它有左子树，

改变order的值为：

3 3 2 0 1 1 1

对于str1中的D，找出它在str2中的位置1，改变order的值为：

3 4 2 0 1 1 1

对于str1中的G，找出它在str2中的位置2，改变order的值为：

3 4 2 0 1 1 1

对于str1中的C，找出它在str2中的位置6，改变order的值为：

5 6 4 0 3 1 2

....

处理完后就得到order的值为5 6 4 0 3 1 2，恰好是后序遍历中str2的字符被反问到的顺序（从大到小）。

代码直接实现如下：

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

const int maxn=100;

int find(char c,char str[])
{
    int len=strlen(str);
    for (int i=0;i<len;i++)
        if (c==str[i]) return i;
    return len;
}

int main()
{
    char str1[maxn],str2[maxn],str[maxn];
    cin>>str1>>str2;//输入前、中序遍历
    int len=strlen(str1);
    if (len!=strlen(str2)) return -1;
    int order[maxn]={0};//order初始化为0
    for (int i=0;i<len;i++)
    {
        int k=find(str1[i],str2);//找到前序第i个字符在中序字符中的位置
        int t=0;
        if (k>0 && order[k-1]==order[k]) t++;//有左子树
        if (k<len-1 && order[k+1]==order[k]) t++;//有右子树

        for (int j=0;j<len;j++) if (order[j]>order[k]) order[j]+=t;//对于上面一层的加深层数

        if (t==2)
        {
            for (int j=k-1;j>=0;j--) if (order[j]>=order[k]) order[j]+=t; else break;//左子树被访问顺序会比右子树快1，所以下面order[j]+=t-1;
            for (int j=k+1;j<len;j++) if (order[j]>=order[k]) order[j]+=t-1; else break;
            continue;
        }

        if (t==1)
        {
            if (k>0 && order[k-1]==order[k])//有左子树
                for (int j=k-1;j>=0;j--) if (order[k]==order[j]) order[j]+=t; else break;
            if (k<len-1 && order[k+1]==order[k])//有右子树
                for (int j=k+1;j<len;j++) if (order[k]==order[j]) order[j]+=t; else break;
        }
    }

    for (int i=0;i<len;i++)//映射中序为后序
        str[len-order[i]-1]=str2[i];

    str[len]=0;
    cout<<str<<endl;//输出
    return 0;
}