问题描述

已知二叉树以二叉链表存储，编写算法完成对于树中每一个元素值为x的节点，删去以它为根的子树，并释放相应空间

算法思想

本题可以分成两个部分来完成。第一步：查找值为x的节点；第二步：删除以值为x的节点为根节点的所有子树；
因为删除的是x的所有子树，因此遍历方式应该选择自上而下的遍历方式，即先序遍历或层次遍历方式，这里选择层次遍历的方式实现。
删除值为x的节点的所有子树，可以考虑使用递归的方式；

即此时可以认为删除的是以值为x的节点作为根节点的树；
首先删除该树的叶子节点，这样该树的倒数第二层节点又会变成新的叶子节点；
接着依次类推，直到值为x的节点变为叶子节点，最后删除自身便可；

算法描述

void FindX(BiTNode* T,ElemType x){
    SqQueue Q;
    InitQueue(&Q);

    BiTNode *p=T;
    EnQueue(&Q,p);

    while(IsEmptyQueue(&Q)!=0){
        p=DeQueue(&Q);
        if(p->lchild!=NULL){
            if(p->lchild->data==x){
                DeleteX(p->lchild);
                p->lchild=NULL;
            }else{
                EnQueue(&Q,p->lchild);
            }
        }
        if(p->rchild!=NULL){
            if(p->rchild->data==x){
                DeleteX(p->rchild);
                p->rchild=NULL;
            }else{
                EnQueue(&Q,p->rchild);
            }
        }
    }
}

void DeleteX(BiTNode* T){
    if(T==NULL){
        return;
    }
    DeleteX(T->lchild);
    DeleteX(T->rchild);
    free(T);
}

具体代码见附件。

附件

//AB#DF##G##C#E##
#include<stdio.h>
#include<stdlib.h>

#define MaxSize 100
typedef char ElemType;

/*-----------------------------------------*/

typedef struct BiTNode{
    ElemType data;
    struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;

BiTNode* CreateBiTree(BiTNode*);
void Judge(BiTNode*);
void PreOrder(BiTNode*);
void InOrder(BiTNode*);
void DeleteX(BiTNode*);
void FindX(BiTNode*,ElemType);

/*-----------------------------------------*/

typedef struct SqQueue{
    BiTNode* data[MaxSize];
    int front, rear;
}SqQueue;

void InitQueue(SqQueue*);
void EnQueue(SqQueue*, BiTNode*);
BiTNode* DeQueue(SqQueue*);
int IsEmptyQueue(SqQueue*);

/*-----------------------------------------*/

int main(int argc, char* argv[]){
    BiTNode *T=(BiTNode*)malloc(sizeof(BiTNode));
    T=CreateBiTree(T);
    Judge(T);

    char x=‘D‘;
    FindX(T,x);

    Judge(T);
    return 0;
}

/*-----------------------------------------*/

BiTree CreateBiTree(BiTNode* T){
    ElemType x;
    scanf("%c",&x);
    if(x==‘#‘){
        return T;
    }else{
        T=(BiTNode*)malloc(sizeof(BiTNode));
        T->data=x;
        T->lchild=CreateBiTree(T->lchild);
        T->rchild=CreateBiTree(T->rchild);
    }
    return T;
}

void DeleteX(BiTNode* T){
    if(T==NULL){
        return;
    }
    DeleteX(T->lchild);
    DeleteX(T->rchild);
    free(T);
}


void FindX(BiTNode* T,ElemType x){
    SqQueue Q;
    InitQueue(&Q);

    BiTNode *p=T;
    EnQueue(&Q,p);

    while(IsEmptyQueue(&Q)!=0){
        p=DeQueue(&Q);
        if(p->lchild!=NULL){
            if(p->lchild->data==x){
                DeleteX(p->lchild);
                p->lchild=NULL;
            }else{
                EnQueue(&Q,p->lchild);
            }
        }
        if(p->rchild!=NULL){
            if(p->rchild->data==x){
                DeleteX(p->rchild);
                p->rchild=NULL;
            }else{
                EnQueue(&Q,p->rchild);
            }
        }
    }
}

/*-----------------------------------------*/

void Judge(BiTNode* T){
    printf("\n");
    PreOrder(T);
    printf("\n");
    InOrder(T);
    printf("\n");
}

void PreOrder(BiTNode* T){
    if(T==NULL){
        return;
    }
    printf("%c",T->data);
    PreOrder(T->lchild);
    PreOrder(T->rchild);
}

void InOrder(BiTNode* T){
    if(T==NULL){
        return;
    }
    InOrder(T->lchild);
    printf("%c",T->data);
    InOrder(T->rchild);
}

/*-----------------------------------------*/

void InitQueue(SqQueue* Q){
    Q->front=0;
    Q->rear=0;
}

void EnQueue(SqQueue* Q, BiTNode* T){
    if((Q->rear+1)%MaxSize==Q->front){
        return;
    }
    Q->data[Q->rear++]=T;
}

BiTNode* DeQueue(SqQueue* Q){
    if(Q->front==Q->rear){
        return NULL;
    }
    return Q->data[Q->front++];
}

int IsEmptyQueue(SqQueue* Q){
    if(Q->front==Q->rear){
        return 0;
    }
    return -1;
}