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

/*====================
由先序遍历，中序遍历建立一颗二叉树
由中序遍历，后序遍历建立一颗二叉树
由先序遍历，中序遍历求后序遍历的结果
由中序遍历，后序遍历求中序遍历的结果
建立一颗二叉排序树
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);
}