树

D.   BST

建立二叉排序树，再后序遍历

关键是会用树,指针有两种用法，右边的写法简单

#include<iostream>
using namespace std;
int n,t;
struct tree{
    int value;
    tree *left,*right;
}*root,*q;

void creat()
{
    if(n>0)
    {
        n--;cin>>t;    
        tree *p;            
        p=new tree;
        p->value=t;p->left=NULL;p->right=NULL;
        tree *q;
        q=root;
        while(1)
        {
            if(t>q->value&&q->right!=NULL)
                q=q->right;
            else if(t<q->value&&q->left!=NULL)
                q=q->left;
            else
                break;
        }
        if(t>q->value)
            q->right=p;
        else
            q->left=p;
        creat();
    }
}

void post(tree **d)                                //         void post(tree *d)
{                                                        //         {
    if(*d==NULL) return;                          //            if(d==NULL) return;  
    else{                                               //            else{
        post(&((*d)->left));                       //                post((d->left));
        post(&((*d)->right));                     //                post((d->right));
        cout<<(*d)->value<<endl;              //                cout<<d->value<<endl;
    }                                                    //             }
}                                                        //         }  

int main()
{
    int test;
    cin>>test;
    while(test--)
    {
        cin>>n;    
        n--;cin>>t;            
        root=new tree;            
        root->value=t;
        root->left=NULL;
        root->right=NULL;
        creat();
        post(&root);                                      //              post(root);

    }
    return 0;
}

 

TOJ 1144.   Tree Recovery

已知前序和中序求后序

方法一：建立二叉树

#include <iostream>
using namespace std;
char first[27];
char middle[27];
struct node
{
char a;
node *left,*right;
};


int pos(char x,int i)
{
int j;
for(j=i;j<strlen(middle);j++){
   if(middle[j]==x) return j;
}
}

void Creat(node **root,int i,int j,int k)//*root
{
int m,leftlen,rightlen;
if(k<=0) *root=NULL;
else{
   *root=new node;
   (*root)->a=first[i];
   m=pos(first[i],j);//找到根结点在中序中的位置
        leftlen=m-j;
   rightlen=k-leftlen-1;
   Creat(&((*root)->left),i+1,j,leftlen);
   Creat(&((*root)->right),i+leftlen+1,m+1,rightlen);
}
}

void Post(node **root)
{
if((*root)==NULL) return;
else{
   Post(&((*root)->left));
   Post(&((*root)->right));
   cout<<(*root)->a;
}
}


int main()
{

while(scanf("%s %s",first,middle )!=EOF){
   node *root;
   Creat(&root,0,0,strlen(first));
   Post(&root);
   cout<<endl;
}
return 0;
}

方法二：数组

#include<iostream>
using namespace std;
int find(char c,char A[],int s,int e)
{
    int i;
    for(i=s;i<=e;i++)
    if(A[i]==c) return i;
}

void pronum(char pre[],int pre_s,int pre_e,char in[],int in_s,int in_e)
{
     char c;
     int k;
     if(in_s>in_e)     return ;                
     if(in_s==in_e){printf("%c",in[in_s]);
                        return ;
                        }
     c=pre[pre_s];                           
     k=find(c,in,in_s,in_e);                 
     pronum(pre,pre_s+1,pre_s+k-in_s,in,in_s,k-1);
     pronum(pre,pre_s+k-in_s+1,pre_e,in,k+1,in_e);
     printf("%c",c);                         
}

int main()
{
    char preord[30],inord[30];
    while(cin>>preord&&cin>>inord)
    {
    pronum(preord,0,strlen(inord)-1,inord,0,strlen(preord)-1);
    cout<<endl;
    }
    return 0;
}