二叉排序树代码实现

参照《大话数据结构》 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);
    }
}