二叉树的遍历转换（层序，中序转先序）

　　众所周知二叉树有四种遍历，即先序（DLR），中序（LDR），后序（LRD）和层序。而层序和其它三种不同，因为它是用的BFS即广度优先搜索。我们可以简单证明中序遍历和其它的任何一种遍历可以确定一棵树。常见的有已知先序中序求后序，已知中序后序求先序（比如noip2001PJ的那道水题）。还有一种不常见的有层序中序求先后序。

　　前面两种太水，递归二分很容易做，后面一种做的时候没反应过来想了会儿，本来想用递归，但是如果用递归的话一会儿二分左子树一会儿二分右子树，不方便，所以我改用队列做。

　　我们用一个队列来储存当前要二分的中序遍历，先将一开始的完整的中序遍历加进去。

　　然后查找当前要处理的中序遍历，将他二分，将左右两部分分别加入队列。再如此处理二分的两部分队列。

　　重复这些操作，直至队列为空（或者说是层序遍历查找完毕），下面是主要部分的源代码;

void make_tree(string str1,string str2,queue <string> que){
que.push(str1);
int now=1;
for(int i = 0; i < str2.length(); i++) {
char &k = str2[i];
string &s = que.front();
string left,right;
int j;
for(j = 0; j < s.length(); j++) {
if(s[j] == k) {
tree[now] = k;
for(int l = j + 1; l < s.length(); l++)
right = right + s[l];
que.push(left);
que.push(right);
que.pop();
break;
}
else
left = left + s[j];
}
now++;
if(j == s.length()) {                   //如果能在s中找到k，则j必定小于lens，而找不到的情况只可能出现在该子树大小为0的情况
i--;
que.push(left);                 //加入一个大小为0的树的中序遍历，防止now不按顺序来，下同
que.push(right);
que.pop();
}
}
}

　　观察上面的源代码，可以发现，我们是将整棵树补齐了，也就是说最坏的情况就是如下图：

其中空心圆表示无结点，实心圆表示结点。

对于N个结点（如图），时间复杂度上界为O(2^n · n^2);（应该没算错吧？？）

如果没算错，那么这样只能最多处理n=19的情况，过大的会超时，那我们该怎么优化这个呢？

首先为什么我们会执行2^n次操作呢？是因为我们如果不存2^n次则无法将每个结点对号入座。

那么我们可不可以用一个队列来存储结点应该做哪个位置呢？答案是可以的。

下面是代码：

#include<iostream>
#include<queue>
#include<string>
#include<sstream>
#include<cstring>
using std::cin;
using std::string;
using std::queue;
char tree[10000 + 20];
int first(int);

int main(){
string str1;    //中序
cin >> str1;
string str2;    //层序
cin >> str2;
queue <string> que;
queue <int> place;
que.push(str1);
place.push(1);
for(int i = 0; i <= 10000 + 19; i++)
tree[i] = '#';
for(int i = 0; i < str2.length(); i++) {
char &k = str2[i];
string &s = que.front();
string left,right;
int j;
for(j = 0; j < s.length(); j++) {
if(s[j] == k) {
tree[place.front()] = k;
for(int l = j + 1; l < s.length(); l++)
right = right + s[l];
if(left.empty() == false) {
que.push(left);
place.push(place.front() * 2);
}
if(right.empty() == false) {
que.push(right);
place.push(place.front() * 2 + 1);
}
que.pop();
break;
}
else
left = left + s[j];
}
place.pop();
}
first(1);
return 0;
}

int first(int x) {
printf("%c" , tree[x]);
if(tree[x * 2] != '#') {
first(x * 2);
}
if(tree[x * 2 + 1] != '#') {
first(x * 2 + 1);
}
}

主要的改变就是用了一个place队列保存下一个元素要出现的位置，这样就用空间换时间

这段代码的时间复杂度为O(n^3)?数学没学好算不出来，总之就是快了好多好多。