Problem Description

设有一棵二叉树，其节点值为字符型并假设各值互不相等，采用二叉链表存储表示。现输入其扩展二叉树的前序遍历序列，建立二叉树，设计一个子函数，要求在该二叉树中查找值为x的结点（假设该结点一定存在），并删除以值x为根结点的子树（包括结点本身，最后输出删除后的二叉树的前序遍历序列）。

 Input

第一行为一个整数n，表示以下有n组数据，每组数据占一行，为扩展二叉树的前序遍历序列，第二行表示要删除的值x。

 Output

输出删除后的二叉树的前序遍历序列。若删除后为空二叉树不输出任何信息。

 Sample Input

2
AB#D##C##
B
ABD##E##C#F##
F

 Sample Output

AC
ABDEC

#include<iostream>
#include<stdio.h>
using namespace std;
struct BiNode{
        char data;
        BiNode *l,*r;
        BiNode(){
                l=r=NULL;
        }
};
class Tree{
public:
    BiNode* p;
        int flag;
        BiNode* temp;
        Tree(){
                root=Creat();
                p=NULL;
                flag=1;
                temp=NULL;
        }

        void PreOder(){
            if(root){

                PreOder(root);
                  cout<<endl;
            }

        }
        void exchange(){

        exchange(root);
        }

   void delete_x(char x){

   delete_x(root,x);
   }

        BiNode* parent(char x){
         parent(root,x,p);
         return temp;
        }
        ~Tree(){
                Release(root);
        }
private:
        BiNode *root;
    void delete_x(BiNode* &bt,char x){
       if(bt){
        if(bt->data==x){
            Release(bt);
            bt=NULL;
        }
        else{
            delete_x(bt->l,x);
            delete_x(bt->r,x);
        }
       }
       }


    void parent(BiNode* root,char x,BiNode* p) {

        if(root) {
            if(root->data==x) {
                temp=p;
                return;
            }
            parent(root->l,x,root);
            parent(root->r,x,root);

        }
    }
    BiNode* Creat() {
                BiNode *bt;
                char ch;
                cin>>ch;
                if(ch=='#'){
                        bt=NULL;
                }else{
                        bt=new BiNode;
                        bt->data=ch;
                        bt->l=Creat();
                        bt->r=Creat();
                }
                return bt;
        }

        void exchange(BiNode* &bt){

        if(bt){
            exchange(bt->l);
            exchange(bt->r);
            BiNode* temp=bt->l;
            bt->l=bt->r;
            bt->r=temp;
        }
        }

        void Release(BiNode *bt){
                if(bt){
                        Release(bt->l);
                        Release(bt->r);
                        delete bt;
                }
        }



        void PreOder(BiNode *bt){
                if(bt){
                        cout<<bt->data;
                        PreOder(bt->l);
                        PreOder(bt->r);
                }

        }

};
int main()
{
  
    int n;
    while(cin>>n) {
        while(n--) {
            Tree t;

            char x;
            cin>>x;
            t.delete_x(x);
            t.PreOder();
        }
    }
    return 0;
}