參照《大話資料結構》 313 ~328頁

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

using namespace std;

/* 二叉樹儲存結構定義*/
typedef int TypeData;
typedef struct BiTreeNode
{
    TypeData data;
    struct BiTreeNode *lchild, *rchild;
}BITREENODE;

void preOrderBiTree(BITREENODE* T);  /* 前序遍歷該二叉樹 */
void inOrderBiTree(BITREENODE* T);  /* 中序遍歷該二叉樹 */
bool searchBST(BITREENODE* T, TypeData key, BITREENODE* f, BITREENODE** p); /* 在二叉樹中查詢key是否存在 */
int insertBST(BITREENODE** T, TypeData key); /* 在二叉排序樹中插入key */

/* 若二叉排序樹T中存在關鍵字等於key的資料元素時，則刪除該資料元素節點
   並返回 TRUE， 否則返回FALSE */
bool deleteBST(BITREENODE** T, TypeData key);

/* 從二叉排序樹助攻刪除節點p，並重接它的左或右子樹 */
bool deleteKey(BITREENODE** p);



int main(void)
{
    BITREENODE* pRoot = NULL;
    int a[10] = {23,56,3,1,100,24,67,77,102,5};
    int i = 0;

    for(i = 0; i < 10; i++)
    {
        insertBST(&pRoot,a[i]);
    }

    /* 中序遍歷該二叉排序樹 */
    inOrderBiTree(pRoot);
    cout << endl;

    /* 刪除節點3 */
    deleteBST(&pRoot,3);

    /* 中序遍歷該二叉排序樹 */
    inOrderBiTree(pRoot);
    cout << endl;


    return 0;
}

/* 若二叉排序樹T中存在關鍵字等於key的資料元素時，則刪除該資料元素節點
   並返回 TRUE， 否則返回FALSE */
bool deleteBST(BITREENODE** T, TypeData key)
{
    /* 沒有找到 */
    if((*T) == NULL)
    {
        return false;
    }
    else
    {
        /* 如果找到，則刪除 */
        if((*T)->data == key)
        {
            return deleteKey(T);
        }
        else if (key < (*T)->data)
        {
            return deleteBST(&(*T)->lchild,key);
        }
        else
        {
            return deleteBST(&(*T)->rchild,key);
        }
    }
}

/* 從二叉排序樹助攻刪除節點p，並重接它的左或右子樹 */
bool deleteKey(BITREENODE** p)
{
    BITREENODE* q = NULL, *s = NULL;

    /* 如果右子樹為空 */
    if ((*p)->rchild == NULL)
    {
        q = *p;
        *p = (*p)->lchild;
        free(q);
    }
    else if((*p)->lchild == NULL)  //如果左子樹為空
    {
        q = *p;
        *p = (*p)->rchild;
        free(q);
    }
    else  //左右子樹都不為空
    {
        q = *p;

        /* 轉左，然後往右走到盡頭，找到待刪除的前驅 */
        s = (*p)->lchild;
        while(s->rchild)
        {
            q = s;
            s = s->rchild;
        }

        /* s節點指向被刪除節點的前驅，把資料直接賦值過來 */
        (*p)->data = s->data;

        if (q != (*p))
        {
            /* 重接q的右子樹 */
            q->rchild = s->lchild;
        }
        else
        {
            /* 重接q的左子樹 */
            q->lchild = s->lchild;
        }

        free(s);
    }
    return true;
}

/* 當二排序樹不存在關鍵字等於key的資料元素時，
   插入key並返回TRUE，否則返回false */
int insertBST(BITREENODE** T, TypeData key)
{
    BITREENODE* p = NULL;
    BITREENODE* pNode = NULL;

    /* 如果沒有查詢成功，則把該節點插入 */
    if(searchBST(*T,key,NULL,&p) == false)
    {

        pNode = (BITREENODE*)malloc(sizeof(BITREENODE));
        pNode->data = key;
        pNode->lchild = pNode->rchild = NULL;

        /* 插入pNode為新的節點 */
        if(p == NULL)
        {
            *T = pNode;
        }
        else if(key < p->data)  //插入的為左孩子
        {
            p->lchild = pNode;
        }
        else
        {
            p->rchild = pNode;  //插入的為右孩子
        }

        return true;
    }

    return false;
}


/* 前序遍歷該二叉樹 */
void preOrderBiTree(BITREENODE* T)
{
    if(T)
    {
       cout << T->data << " ";
       preOrderBiTree(T->lchild);
       preOrderBiTree(T->rchild);
    }
}

/* 中序遍歷該二叉樹 */
void inOrderBiTree(BITREENODE* T)
{
    if(T)
    {
       inOrderBiTree(T->lchild);
       cout << T->data << " ";
       inOrderBiTree(T->rchild);
    }
}


/* 遞迴查詢二叉排序樹T中是否存在key，
   指標f指向T的雙親，其初始呼叫值為NULL
   若查詢成功，則指標p指向該資料元素節點，並返回 TRUE
   否則指標p指向查詢路徑上訪問最後一個節點並返回 FALSE
 */
bool searchBST(BITREENODE* T, TypeData key, BITREENODE* f, BITREENODE** p)
{
    if(NULL == T)
    {
        *p = f;
        return false;
    }
    else if(T->data == key)
    {
        *p = T;
        return true;
    }
    else if(key < T->data)
    {
        /* 遞迴查詢左子樹 */
        return searchBST(T->lchild, key, T, p);
    }
    else
    {
        /* 遞迴查詢右子樹 */
        return searchBST(T->rchild, key, T, p);
    }
}