由树的前序遍历，中序遍历建立一颗二叉树，并以后续遍历的方式输出其元素

/*====================
由先序遍历，中序遍历建立一颗二叉树
由中序遍历，后序遍历建立一颗二叉树
由先序遍历，中序遍历求后序遍历的结果
由中序遍历，后序遍历求中序遍历的结果
建立一颗二叉排序树
2013-08-15 By Mei
======================*/

#include <iostream>
#include <stack>
#include <queue>

using namespace std;

typedef struct Binode
{
char data;
struct Binode *lchild, *rchild;
}Binode, *Bitree;

Bitree Create(char *pre, char *in, int length)
{
int flag;
if(length<=0)
return NULL;
Bitree node = new Binode;
node->data = *pre;

for(flag=0; flag<length; ++flag)
{
if(*pre == in[flag])
break;
}
node->lchild = Create(pre+1, in, flag);
node->rchild = Create(pre+1+flag, in+flag+1,length-flag-1);
cout<<node->data<<" ";
return node;
}

Bitree Insert(Bitree root, char value)
{
Bitree p = root;
Bitree pre;
Bitree node = new Binode;
node->data = value;
while(p!=NULL)
{
pre = p;
if(value < p->data)
p = p->lchild;
else
p = p->rchild;
}
if(value < pre->data)
pre->lchild = node ;
else
pre->rchild = node ;

node->rchild = node->lchild = NULL;
return root;
}

Bitree Create_Sort(char *p, int n)
{
Bitree root = new Binode;
int flag = 0;
root->data = p[flag++];
root->rchild = root->lchild = NULL;
for(int i=1; i<n; ++i)
Insert(root, *(p+i));
return root;
}

void Intraverse(Bitree root)
{
stack<Bitree> st;
Bitree p = root;
while(p!=NULL||!st.empty())
{
while(p!=NULL)
{
st.push(p);
p = p->lchild;
}
if(!st.empty())
{
p = st.top();
st.pop();
cout << p->data <<" ";
p = p->rchild;
}
}
}

//层次遍历
void TraverseofLevel(Bitree root)
{
queue<Bitree > st;
Bitree p = root;
st.push(root);
while(!st.empty())
{
p = st.front();
st.pop();
cout<<p->data<<" ";
if(p->lchild!=NULL)
st.push(p->lchild);
if(p->rchild!=NULL)
st.push(p->rchild);
}
}

int main()
{
Bitree p;
char pre[] ={'G','D', 'A','F','E' ,'M' ,'H' ,'Z'};
char in[] = {'A','D','E','F', 'G', 'H', 'M', 'Z'};
int len = sizeof(pre)/sizeof(char);
Create(pre, in, len);
cout<<endl;
p = Create_Sort(pre, len);
Intraverse(p);
cout<<endl;
TraverseofLevel(p);
}