swust oj 1052

输出利用先序遍历创建的二叉树中的指定结点的双亲结点

1000(ms)

10000(kb)

2415 / 5575

利用先序递归遍历算法创建二叉树并输出该二叉树中指定结点的双亲结点。约定二叉树结点数据为单个大写英文字符。当接收的数据是字符“#”时表示该结点不需要创建，否则创建该结点。最后再输出创建完成的二叉树中的指定结点的双亲结点。注意输入数据序列中的“#”字符和非“#”字符的序列及个数关系，这会最终决定创建的二叉树的形态。

输入

输入用例分2行输入，第一行接受键盘输入的由大写英文字符和“#”字符构成的一个字符串（用于创建对应的二叉树），第二行为指定的结点数据。

输出

用一行输出该用例对应的二叉树中指定结点的双亲结点。若相应双亲结点不存在则以“#”代替。

样例输入

A##
A
ABC####
B

样例输出

#
A 

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cstdio>
typedef char Datetype;
using namespace std;
char x;

typedef struct link{
    Datetype date;
    struct link *lchild;
    struct link *rchild;
}tree;

typedef struct queue{
    tree *data;
    struct queue *next;
}que;

typedef struct {
    que *front;
    que *rear;
}lin;

void Initqueue(lin *&L)
{
    L=(lin *)malloc(sizeof(lin));
    L->front=L->rear=NULL;
}

void destroyed(lin *&L)
{
    que *p=NULL,*r=NULL;
    p=L->front;
    while(p!=NULL)
    {
        r=p;
        p=p->next;
        free(r);
    }
    free(L);
}

bool pop(lin *&L, tree *&e)
{
    que *p;
    if(L->rear==NULL)
        return false;
    p=L->front;
    if(L->rear==L->front)
        L->front=L->rear=NULL;
    else
        L->front=p->next;
    e=p->data;
    free(p);
    return true;
}

int empty(lin *&L)
{
    return (L->rear==NULL);
}

void push(lin *&L,tree *e)
{
    que *p;
    p = (que *)malloc(sizeof(que));
    p->data=e;
    p->next=NULL;
    if(L->rear==NULL)
    {
        L->front=p;
        L->rear=p;
    }
    else
    {
        L->rear->next=p;
        L->rear=p;
    }
}

void creattree(tree *&L)
{
    char c;
    cin>>c;
    if(c=='#')
        L=NULL;
    else
    {
        L = (tree *)malloc(sizeof(tree)) ;
        L->date=c;
        creattree(L->lchild);
        creattree(L->rchild);
    }
}

void find(tree *L)
{
    if(L!=NULL)
    {
        x++;
        find(L->rchild);
    }
}

void destroytree(tree *&L)
{
    if(L!=NULL)
    {
        destroytree(L->lchild);
        destroytree(L->rchild);
        free(L);
    }
}

int deep(tree *L)
{
    int ldep,rdep,max;
    if(L!=NULL)
    {
        ldep=deep(L->lchild);
        rdep=deep(L->rchild);
        max=ldep>rdep?ldep+1:rdep+1;
        return max;
    }
    else
        return 0;
}

void finddegree(tree *&L, int n)
{
    if(L!=NULL)
    {
        if(x<n)
            x=n;
        finddegree(L->lchild,n);
        finddegree(L->rchild,n+1);
    }

}

void run(tree *L)
{
    tree *p=L;
    lin *qu;
    Initqueue(qu);
    if(L!=NULL)
        push(qu,p);
    while(!empty(qu))
    {
        pop(qu,p);
        cout<<p->date;
        if(p->lchild!=NULL)
            push(qu,p->lchild);
        if(p->rchild!=NULL)
            push(qu,p->rchild);
    }
    destroyed(qu);
}

void displayhou(tree *&L)
{
    if(L!=NULL)
    {
        displayhou(L->lchild);
        displayhou(L->rchild);
        cout<<L->date;
    }
}

void displaypre(tree *&L)
{
    if(L!=NULL)
    {
        cout<<L->date;
        displaypre(L->lchild);
        displaypre(L->rchild);
    }
}

void creatinpre(tree *&L ,char *in,char *pre,int x)
{
    int k=0;
    char *p;
    if(x<=0)
    {
        L=NULL;
        return ;
    }
    L=(tree *)malloc(sizeof(tree));
    L->date = *pre;
    for(p=in ; p<in+x; p++)
    {
        if(*p==*pre)
            break;
    }
    k=p-in;
    creatinpre(L->lchild,in,pre+1,k);
    creatinpre(L->rchild,p+1,pre+k+1,x-k-1);
}

void creatinhou(tree *&L ,char *in,char *pre,int x)
{
    int k=0;
    char *p;
    if(x<=0)
    {
        L=NULL;
        return ;
    }
    L=(tree *)malloc(sizeof(tree));
    L->date = *pre;
    for(p=in ; p>in-x; p--)
    {
        if(*p==*pre)
            break;
    }
    k=in-p;
    creatinhou(L->rchild,in,pre-1,k);
    creatinhou(L->lchild,p-1,pre-k-1,x-k-1);
}

void findson(tree *&L)
{
    if(L!=NULL)
    {
        if(L->date==x)
        {
            if(L->lchild==NULL)
                cout<<"L:#";
            else
                cout<<"L:"<<L->lchild->date;
            if(L->rchild==NULL)
                cout<<",R:#";
            else
                cout<<",R:"<<L->rchild->date;
            return ;
        }
        findson(L->lchild);
        findson(L->rchild);
    }
}

void finddad(tree *&L)
{
    if(L!=NULL)
    {
        if(L->lchild!=NULL&&L->lchild->date==x||L->rchild!=NULL&&L->rchild->date==x)
        {
            cout<<L->date;
            return ;
        }

        finddad(L->lchild);
        finddad(L->rchild);
    }
}

int main()
{
    tree *L = NULL;
    creattree(L);
    cin>>x;
    if(x==L->date)
        cout<<"#";
    else
        finddad(L);
    destroytree(L);
    return 0;
}