6-2 二叉排序树基本运算(C++)

要求实现二叉排序的基本运算，包括创建二叉排序树、查找、删除结点等运算。

函数接口定义：

typedef int KeyType;            //定义关键字类型
typedef struct node                   //记录类型
{    
    KeyType key;                      //关键字项
    struct node *lchild,*rchild;    //左右孩子指针
} BSTNode;

int ReadData(int a[])   //键盘输入若干个整数，顺序保存在数组a中，并返回输入整数的数量。由裁判程序实现，细节不表。
BSTNode *CreatBST(KeyType A[],int n)    //顺序读入数组A中的关键字, 依序建立一棵二叉排序树并返回根结点指针. 
int DeleteBST(BSTNode *&bt,KeyType k)   //在bt中删除关键字为k的节点. 找到关键字k并删除返回1，否则返回0。
int SearchBST(BSTNode *bt,KeyType k)    //输出从根节点到查找到的节点的路径 ,如果找到k,返回1，否则返回0。提示：输出语句格式如：printf("%d ",bt->key);
void InorderTraversal(BSTNode *bt)      //中序遍历并输出该二叉排序树。由裁判程序实现，输出语句格式如：printf("%d ",bt->key);
void PreorderTraversal(BSTNode *bt)     //先序遍历并输出该二叉排序树。由裁判程序实现，输出语句格式如：printf("%d ",bt->key);

裁判测试程序样例：

int main()
{
    BSTNode *bt=NULL;
    KeyType k,X;
    int a[100],N;
    N=ReadData(a);  //键盘读入N个整数，顺序保存在数组a中. 裁判程序实现，细节不表。
    bt=CreatBST(a,N); //根据数组a,创建一棵BST树
    printf("Preorder: "); PreorderTraversal(bt); printf("\n"); //先序遍历并输出该二叉排序树。
    scanf("%d", &k);  //输入待查找的关键字k
    SearchBST(bt,k);printf("\n");  //查找k，并输出从根节点到查找到的节点的路径 ,如果找到k,返回1，否则返回0 
    scanf("%d", &k);  //输入待删除的关键字k
    DeleteBST(bt,k);  //在二叉排序树中删除关键字为k的结点。
    printf("Inorder: "); InorderTraversal(bt); printf("\n");   //中序遍历并输出该二叉排序树。
    return 0;
}

/* 请在这里填写答案 */

输入样例：

在这里给出一组输入。例如：

10
4 9 0 1 8 6 3 5 2 7
6
4

输出样例：

在这里给出相应的输出。例如：

Preorder: 4 0 1 3 2 9 8 6 5 7 
4 9 8 6 
Inorder: 0 1 2 3 5 6 7 8 9 

BSTNode *CreatBST(KeyType A[],int n){
     BSTNode *T, *p, *parentOfp;
     T = NULL;
     for(int i = 0; i < n; ++ i){
        p = T, parentOfp = NULL;
        while(p && A[i] != p->key){
            if(A[i] < p->key){
                parentOfp = p;
                p = p->lchild;
            }else{
                parentOfp = p;
                p = p->rchild;
            }
        }

        if(!p){
            BSTNode *q;
            q = (BSTNode*)malloc(sizeof(BSTNode));
            q->key = A[i];
            q->lchild = NULL;
            q->rchild = NULL;
            if(!parentOfp) T = q;
            else if(A[i] < parentOfp->key) parentOfp->lchild = q;
            else parentOfp->rchild = q;
        }
     }
     return T;
}

int SearchBST(BSTNode *bt,KeyType k){
    BSTNode *p = bt;
    while(p && p->key != k){
        printf("%d ", p->key);
        if(k < p->key){
            p = p->lchild;
        }else{
            p = p->rchild;
        }
    }
    if(!p) return 0;
    else{
        printf("%d ", p->key);
        return 1;
    }
}

int DeleteBST(BSTNode *&bt,KeyType k){
    BSTNode *p, *parentOfp;
    p = bt, parentOfp = NULL;
    while(p && p->key != k){
        if(k < p->key){
            parentOfp = p;
            p = p->lchild;
        }else{
            parentOfp = p;
            p = p->rchild;
        }
    }
    if(!p) return 0;
    
    if(p->lchild && p->rchild){
        BSTNode *q, *parentOfq;
        parentOfq = p, q = p->lchild;
        while(q->rchild){
            parentOfq = q;
            q = q->rchild;
        }
        
        p->key = q->key;
        
        if(parentOfq->lchild == q){
            parentOfq->lchild = q->lchild;
        }else{
            parentOfq->rchild = q->lchild;
        }
        
        free(q);
    }
    else if(!p->lchild){
        if(!parentOfp){
            bt = p->rchild;
            free(p);
        }else if(parentOfp->lchild == p){
            parentOfp->lchild = p->rchild;
            free(p);
        }else{
            parentOfp->rchild = p->rchild;
            free(p);
        }
    }else{
        if(!parentOfp){
            bt = p->lchild;
            free(p);
        }else if(parentOfp->lchild == p){
            parentOfp->lchild = p->lchild;
            free(p);
        }else{
            parentOfp->rchild = p->lchild;
            free(p);
        }
    }
    return 1;
}