7-2 二叉搜索树的删除操作

给出一棵二叉搜索树（没有相同元素）, 请输出其删除部分元素之后的层序遍历序列。

删除结点的策略如下：

• 如果一个结点是叶子结点，则直接删除；
• 如果一个结点的左子树不为空, 则将该结点的值设置为其左子树上各结点中的最大值，并继续删除其左子树上拥有最大值的结点；
• 如果一个结点的左子树为空但右子树不为空，则将该结点的值设置为其右子树上各结点中的最小值，并继续删除其右子树上拥有最小值的结点。

输入格式:

每个输入文件包含一个测试用例。每个测试用例的第一行包含一个整数 N (0<N<=100)，表示二叉搜索树中结点的个数。
第二行给出该二叉搜索树的先序遍历序列，由 N 个整数构成，以一个空格分隔。第三行给出一个整数K (0<K<N)，表示待删除的结点个数。最后一行给出 K 个整数，表示待删除的各个结点上的值。必须按输入次序删除结点。题目保证结点一定能被删除。

输出格式:

在一行中输出删除结点后的层序遍历序列。序列中的数字以一个空格分隔，行末不得有多余空格。

输入样例:

7
4 2 1 3 6 5 7
2
3 6

输出样例:

4 2 5 1 7

#include <stdio.h>

typedef struct BiTNode{
	struct BiTNode *lchild;
	struct BiTNode *rchild;
	int data;
}BiTNode;

//初始化操作
BiTNode *InitBiTree(){
	BiTNode* t =(BiTNode *)malloc(sizeof(BiTNode));
	t->lchild = NULL;
	t->rchild = NULL;
	return t;
}

//建立二叉搜素树
void GetNode(BiTNode *bt)
{
    int x;
    BiTNode* t =InitBiTree();
    scanf("%d",&t->data);
    BiTNode* q=bt;
    while(1)
    {
        if(t->data<q->data)
        {
            if(!q->lchild)
            {
                q->lchild=t;
                break;
            }
            else
            {
                q=q->lchild;
            }
        }
        else
        {
            if(!q->rchild)
            {
                q->rchild=t;
                break;
            }
            else
            {
                q=q->rchild;
            }
        }
    }
}

//寻找结点,通过二叉树和结点的值 
BiTNode* FindNode(BiTNode *bt,int x)
{
    int y=1;
    BiTNode* q=bt;
    BiTNode* s=bt;
    if(bt->data==x)
    {
        y=0;
    }
    while(y!=0)
    {
        if(x<q->data)
        {
            if(!q->lchild)
            {
                break;
            }
            else 
            {
                q=q->lchild;
            }
        }
        else if(x>q->data)
        {
            if(!q->rchild)
            {
                break;
            }
            else 
            {
                q=q->rchild;
            }
        }
        if(q->data==x)
        {
            break;
        }
    }
    return q;
}
//寻找结点的父亲，通过二叉树和结点的值 
BiTNode* FindNodeFather(BiTNode *bt,int x)
{
    int y=1;
    BiTNode* q=bt;
    BiTNode* s=bt;
    if(bt->data==x)
    {
        y=0;
    }
    while(y!=0)
    {
        if(x<q->data)
        {
            if(!q->lchild)
            {
                printf("It does not exist.");
                break;
            }
            else 
            {
                s=q;
                q=q->lchild;
            }
        }
        else if(x>q->data)
        {
            if(!q->rchild)
            {
                printf("It does not exist.");
                break;
            }
            else 
            {
                s=q;
                q=q->rchild;
            }
        }
        if(q->data==x)
        {
            break;
        }
    }
    return s;
}
//删除结点，通过二叉树和结点的地址，递归删除 
void DeleteNode(BiTNode *Node,BiTNode *bt)
{
    BiTNode *q=Node;
    int dataa;
    if((!q->lchild)&&(!q->rchild))
    {
    	//通过父亲删除子结点，来达到删除结点的目的 
        BiTNode *f=FindNodeFather(bt,q->data);
        if(q->data<f->data)f->lchild=NULL;
        if(q->data>f->data)f->rchild=NULL;
    }
    else if(q->lchild)
         {
            dataa=FindMax(q);
            DeleteNode(FindNode(bt,dataa),bt);
            q->data=dataa;
         }
         else 
         {
            dataa=FindMin(q);
            DeleteNode(FindNode(bt,dataa),bt);
            q->data=dataa;
         }
}
//寻找左子树中所有结点中最大的值 
int FindMax(BiTNode *Node)
{
    int max;
    BiTNode *q=Node->lchild;
    while(1)
    {   if(!q->rchild)
        {   
            max=q->data;
            break;
        }
        else q=q->rchild;
    }
    return max;
}
//寻找右子树中所有结点中最小的值                  
int FindMin(BiTNode *Node)
{
    int min;
    BiTNode *q=Node->rchild;
    while(1)
    {   if(!q->lchild)
        {   
            min=q->data;
            break;
        }
        else q=q->lchild;
    }
    return min;
}
//层序遍历，需要一个队列或数组，我这里是用的数组 
void FloorPrint(BiTNode *bt)
{
	BiTNode* temp[100];
	int in=0;
	int out=0;
	temp[in++]=bt;
	while(in>out)
	{
		if(temp[out])
		{
			printf("%d",temp[out]->data);
			if(temp[out]->lchild)temp[in++]=temp[out]->lchild;
			if(temp[out]->rchild)temp[in++]= temp[out]->rchild;
		}
		out++;
		if(out!=in)printf(" ");
	}
}

int main()
{
    int n,N,a,b,x;
    BiTNode *bt  =  InitBiTree();
    //构建二叉树 
    scanf("%d",&n);
    for(N=0;N<n;N++)
    {
        if(N==0)
        {
            scanf("%d",&bt->data);
        }
        else
        {
            GetNode(bt);
        }
	}
	// 删除结点 
    scanf("%d",&a);
    for(b=0;b<a;b++)
    {
        scanf("%d",&x);
        DeleteNode(FindNode(bt,x),bt);
    } 
    //层序遍历 
	FloorPrint(bt);
}