二叉查詢樹的相關操作

二叉查詢樹是專門用於二叉樹的查詢，一般的二叉樹查詢都是通過遍歷來實現，二叉查詢樹能有效提高查詢效率。

• 構造一個空的二叉查詢樹
• 二叉查詢樹T存在，銷燬樹T
• 在二叉查詢樹中查詢值為e.key的結點
• 往二叉查詢樹中插入值為e.key的結點
• 刪除二叉查詢樹中值為key的結點

---

程式碼實現

//  Binary_Search_Tree

#include<stdio.h>
#include<stdlib.h> 

#define  TRUE   1
#define  FALSE  0
#define  OK     1
#define  ERROR  0
#define  OVERFLOW   -1
typedef  int  Status;


typedef struct {
  int key;  
} TElemType;
typedef struct BSTNode {
    TElemType data;
    struct BSTNode *lchild, *rchild;
} BSTNode, *BSTree;


//  構造一個空的二叉查詢樹 
Status InitBST (BSTree &T) {
    T = NULL; 
}

//  銷燬樹 
Status DestroyBST(BSTree &T) {
    if(T->lchild != NULL)  
        DestroyBST(T->lchild);  
    if(T->rchild != NULL)  
        DestroyBST(T->rchild);  
    T = NULL;  
}


// 若二叉查詢樹 T 中存在值為 key 的結點，則返回該結點指標，否則返回 NULL
BSTree SearchBST(BSTree T, int key) {
    if(NULL == T) return NULL; // 查詢失敗
    if(T->data.key == key) return T;
    if(T->data.key > key) {
        return SearchBST(T->lchild, key);
    }
    return SearchBST(T->rchild, key);
}


//  若二叉查詢樹 T 中不存在值為 e.key 的結點，則插入到 T 
Status InsertBST(BSTree &T,TElemType e) {
    if(NULL == T) {
        BSTNode *s;
        s = (BSTNode*) malloc (sizeof(BSTNode));
        if(NULL == s) return OVERFLOW;
        s->data = e; 
        s->lchild = NULL;
        s->rchild = NULL;
        T = s;
        return TRUE;
    }
    if(e.key < T->data.key) return InsertBST(T->lchild,e);
    if(e.key > T->data.key) return InsertBST(T->rchild,e);
    return FALSE;
} 


// 刪除結點操作 
void DeleteNode(BSTree &p) {
    BSTNode *q,*s;
    q = p;
    if(NULL == p->rchild) {
        p = p->lchild;
        free(q);
    }   else if(NULL == p->lchild) {
        p = p->rchild;
        free(q);
    }   else {
        s = p->lchild;
        while (s->rchild != NULL) {
            q = s;
            s = s->rchild;
        }
        p->data = s->data;
        if(q == p)
            q->lchild = s->lchild;
        else q->rchild = s->lchild;

        free(s);
    }
}


// 若二叉查詢樹 T 中存在值為 key 的結點，則刪除 
Status DeleteBST(BSTree &T,int key) {
    if(NULL == T) return FALSE;
    if(key == T->data.key) {
        DeleteNode(T);
        return TRUE;
    }
    else if(key < T->data.key)
        return DeleteBST(T->lchild,key);
    return DeleteBST(T->rchild,key);
}


//  輸出樹 
void puttree(BSTree &t){
    if(NULL == t) return ;
    else{
        puttree(t->lchild);
        printf("%d  ",t->data);
        puttree(t->rchild);
    }
} 


int main() {
    TElemType E;
    int i;
    int key_1, key_2, key_3;
    int a[10]; 
    BSTree t, temp_1, temp_2;
    Status temp_3;

    printf("enter array a[10](integer):\n");
    for(i = 0;i < 10;i++) {     //構造陣列a[10] 
        scanf("%d",&a[i]);
    }

    InitBST(t);     // 構造一個空的二叉查詢樹

    for(i = 0;i<10;i++) {
        E.key = a[i];
        InsertBST(t,E);     // 插入值為 E.key的結點 
    }
    printf("Tree is made up from array a[10]:\n");
    puttree(t);     // 輸出樹 
    printf("\n");

    printf("enter key_1(for searching), key_2(for searching), key_3(for deleting):\n");
    scanf("%d %d %d",&key_1, &key_2, &key_3);

    temp_1 = SearchBST(t,key_1);
    if(temp_1) {    // 查詢是否有存在結點值為key_1 
        printf("%d\n", temp_1->data.key);
    }   else {
        printf("%d can't be found\n",key_1);
    }
    temp_2 = SearchBST(t,key_2);
    if(temp_2) {    // 查詢是否有存在結點值為key_2 
        printf("%d\n", temp_2->data.key);
    }   else {
        printf("%d can't be found\n",key_2);
    }


    temp_3 = DeleteBST(t,key_3);
    if(temp_3 == TRUE) {    //刪除值為key_3的結點 
        printf("%d has been delete\n", key_3);
    } else {
        printf("%d can't be found\n",key_3);
    }

}