数据结构问题根据广义表创建二叉树的四种遍历方式

Description

输入广义表表示法表示的二叉树的字符串，以#作为字符串结束标志，将广义表形式的字符串创建为链式存储结构的二叉树，并先序、中序和后序遍历该二叉树，输出先序、中序和后序遍历的序列

Input

广义表形式的字符串

Output

先序遍历的序列 
中序遍历的序列 

后序遍历的序列

按层次遍历的序列

Sample Input

A(B,C(,E))#

Sample Output

ABCE
BACE
BECA

Hint

每种遍历之间换行 
字符串的长度不超过100个字符 

一个字母表示一个节点

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <queue>
#include <cctype>
using namespace std;

#define N 100
typedef char Element;

struct Node
{
    Element data;
    struct Node *lchild;
    struct Node *rchild;
};

typedef struct Node BTNode;
typedef struct Node * BTree;
BTree Create_BTree(char s[]);
BTree NewNode(Element x);
void Pre_Order(BTree root);
void In_Order(BTree root);
void Post_Order(BTree root);
void Level_Order(BTree root);

int main()
{
    char s[N];
    BTree root=NULL;
    gets(s);
    root=Create_BTree(s);
    Pre_Order(root);
    printf("\n");
    In_Order(root);
    printf("\n");
    Post_Order(root);
    printf("\n");
    Level_Order(root);
    printf("\n");
    return 0;
}

BTree NewNode(Element x)        //创建二叉树节点，返回节点指针
{
    BTree p=(BTree)malloc(sizeof(BTNode));
    p->data=x;
    p->lchild=NULL;
    p->rchild=NULL;
    return p;
}

BTree Create_BTree(char s[])      //创建二叉树
{
    int i,k,top;
    BTree path[N],p;
    k=0;
    top=-1;
    for(i=0;s[i]!='#';i++)
    {
        switch(s[i])
        { 
        case '(':
            path[++top]=p;
            k=1;
            break;
        case ',':
            k=2;
            break;
        case ')':
            top--;
            break;
        } 
        if(isalpha(s[i]))
        {
            p=NewNode(s[i]);
            if(k==1)
                path[top]->lchild=p;
            else if(k==2)
                path[top]->rchild=p;
        }
    } 
    return path[0];
}

void Pre_Order(BTree root)      //前序遍历
{
    if(root!=NULL)
    {
        printf("%c",root->data);
        Pre_Order(root->lchild);
        Pre_Order(root->rchild);
    }
}

void In_Order(BTree root)      //中序遍历
{
    if(root!=NULL)
    {
        In_Order(root->lchild);
        printf("%c",root->data);
        In_Order(root->rchild);
    }
}

void Post_Order(BTree root)      //后序遍历
{
    if(root!=NULL)
    {
        Post_Order(root->lchild);
        Post_Order(root->rchild);
        printf("%c",root->data);
    }
}

void Level_Order(BTree root)        //层次遍历
{
    BTree q[N],p;
    int front=0 ,rear=0;
    if(root!=NULL)
    {
        rear=(rear+1)%N;
        q[rear]=root;
    } 
    while(front!=rear)
    {
        front=(front+1)%N;
        p=q[front];
        printf("%c",p->data);
        if(p->lchild!=NULL)
        {
            rear=(rear+1)%N;
            q[rear]=p->lchild;
        } 
        if(p->rchild!=NULL)
        {
            rear=(rear+1)%N;
            q[rear]=p->rchild;
        }
    }
}