bsTree.h

#ifndef BSTREE_H_INCLUDED
#define BSTREE_H_INCLUDED

#undef NULL
#ifdef __cplusplus
    #define NULL 0
#else
    #define NULL ((void *)0)
#endif

/*
二叉查找树(Binary Search Tree),(又:二叉搜索树,二叉排序树)
它是一棵空树或者具有以下性质:
    若它的左子树不空,则左子树上所有结点的值均小于它的根结点的值;
    若它的右子树不空,则右子树上所有结点的值均大于它的根结点的值;
    它的左、右子树也分别为二叉排序树。
后继:
    如果二叉查找树的关键字互不相同,则一个节点x的后继是大于x.key的最小关键字节点。
简单来说:前驱就是节点x左子树key最大的节点,后继是节点x右子树中key最小的节点。
*/

typedef struct tag_bsTree
{
    struct tag_bsTree *pLNode;  //左孩子
    struct tag_bsTree *pRNode;  //右孩子
    struct tag_bsTree *pPNode;  //双亲、
    int key;
}bsTree;

//为树分配一个新节点
bsTree* getBsNode(int key);

/*
将一个节点插入bsTree。按照插入节点的大小以及二叉树的性质插入
*/
bsTree* bsInsert(bsTree *pNewTreeNode, bsTree* pstBsRoot);

//查找
bsTree* bsSearch(int key , bsTree* pstBsRoot);

/*
在二叉查找树种删除一个元素,返回bool。
分三种情况进行处理:
  1.p为叶子节点,直接删除该节点,再修改其父节点的指针
  2.p为单支节点(即只有左子树或右子树)。让p的子树与p的父亲节点相连,删除p即可
  3.p的左子树和右子树均不空。找到p的后继y,因为y一定没有左子树,所以可以删除y,并让y的父亲节点成为y的右子树的父亲节点,并用y的值代替p的值;或者方法二是找到p的前驱x,x一定没有右子树,所以可以删除x,并让x的父亲节点成为y的左子树的父亲节点。如图c。
*/
bsTree* bsDel(bsTree *pstDelNode, bsTree *pstBsRoot);

//获取pstBsRoot之后的最大key所在位置
bsTree *bsGetMaxNode(bsTree *pstBsRoot);
//获取pstBsRoot之后的最小key所在位置
bsTree *bsGetMinNode(bsTree *pstBsRoot);
//获取pNode的后继
bsTree* bsGetNext(bsTree *pNode);
//获取pNode的前驱
bsTree* bsGetPre(bsTree *pNode);

#endif // BSTREE_H_INCLUDED

bsTree.c

#include "bsTree.h"
#include "memory.h"

#define RETURN_ERR -1
#define RETURN_OK 0

bsTree* getBsNode(int key)
{
    bsTree *pNewNode = NULL;

    pNewNode = (bsTree*)malloc(sizeof(bsTree));
    if (NULL == pNewNode)
    {
        return NULL;
    }

    memset(pNewNode, 0, sizeof(bsTree));
    pNewNode->key = key;

    return pNewNode;
}

/*
函数功能:插入一个节点到二叉查找树
函数入参:bsTree *pNewTreeNode 待插入节点
          bsTree* pstBsRoot 二叉树的根节点
函数出参:无
函数返回值:二叉树根节点(有可能改变二叉树根节点的位置)
其他: 该函数也可以使用递归实现
*/
bsTree* bsInsert(bsTree *pNewTreeNode, bsTree* pstBsRoot)
{
    bsTree *pstTmp = NULL;
    bsTree *pstPar = NULL;  //父节点的位置

    //如果新节点是空,则入参错误
    if (NULL == pNewTreeNode)
    {
        return NULL;   //返回NULL,要求调用者需要先判断返回值,返回值不空才能修改根节点的位置
    }

    pstTmp = pstBsRoot;

    while (NULL != pstTmp)
    {
        pstPar = pstTmp;    //先保存父节点

        if (pNewTreeNode->key <= pstTmp->key)      //严格来说如果等于条件成立,说明节点存在不允许再次插入,需要清理pNewTreeNode的内存
        {
            pstTmp = pstTmp->pLNode;
        }
        else
        {
            pstTmp = pstTmp->pRNode;
        }
    }

    pNewTreeNode->pPNode = pstPar;

    if (NULL == pstPar)
    {
        pstBsRoot = pNewTreeNode;
    }
    else if (pNewTreeNode->key <= pstPar->key)
    {
        pstPar->pLNode = pNewTreeNode;
    }
    else
    {
        pstPar->pRNode = pNewTreeNode;
    }

    return pstBsRoot;
}

/*
函数功能:根据key确定节点在二叉查找树的位置
函数入参:int key 待查找节点的key值
          bsTree* pstBsRoot 树的根节点
函数出参:无
函数返回值:key对应的节点在二叉查找树中的位置,找不到返回NULL
其他: 该函数也可以使用递归实现
*/
bsTree* bsSearch(int key , bsTree* pstBsRoot)
{
    bsTree *pTmp = pstBsRoot;

    while (NULL != pTmp)
    {
        if (key < pTmp->key)
        {
            pTmp = pTmp->pLNode;
        }
        else if (key > pTmp->key)
        {
            pTmp = pTmp->pRNode;
        }
        else
        {
            break;
        }
    }

    return pTmp;
}

/*
函数功能:删除一个节点
函数入参:bsTree *pstDelNode  待删除节点的位置
          bsTree* pstBsRoot 二叉树的根节点
函数出参:无
函数返回值:删除后的根节点
其他:
*/
bsTree* bsDel(bsTree *pstDelNode, bsTree *pstBsRoot)
{
    bsTree *pTmp1 = NULL;
    bsTree *pTmp2 = NULL;

    //待删除节点的左孩子或者右孩子为空
    if ((NULL == pstDelNode->pLNode) || (NULL == pstDelNode->pRNode))
    {
        pTmp2 = pstDelNode;
    }
    else
    {
        pTmp2 = bsGetNext(pstDelNode);  //pstDelNode的左右孩子都不为空的时候,需要找到该节点的后继
    }

    if (NULL != pTmp2->pLNode)
    {
        pTmp1 = pTmp2->pLNode;      //后继节点的左孩子不为空,则保持后继的左孩子
    }
    else
    {
        pTmp1 = pTmp2->pRNode;      //此时pTmp1,有可能为空
    }

    if (NULL != pTmp1)
    {
        pTmp1->pPNode = pTmp2->pPNode;
    }

    if (NULL == pTmp2->pPNode)
    {
        pstBsRoot = pTmp1;
    }
    else if (pTmp2 == pTmp2->pPNode->pLNode)
    {
        pTmp2->pPNode->pLNode = pTmp1;
    }
    else
    {
        pTmp2->pPNode->pRNode = pTmp1;
    }

    if (pTmp2 != pstDelNode)
    {
        pstDelNode->key = pTmp2->key;
    }

    if (NULL != pTmp2)
    {
        free(pTmp2);
    }

    return pstBsRoot;   //删除节点的时候根节点肯定存在(或为NULL)
}

//获取pstBsRoot之后的最大key所在位置
bsTree *bsGetMaxNode(bsTree *pstBsRoot)
{
    bsTree *pTmp = pstBsRoot;

    if (NULL == pstBsRoot)
    {
        return NULL;    //子树不存在
    }

    while (NULL != pTmp->pRNode)    //为空的时候就查找到了哦
    {
        pTmp = pTmp->pRNode;
    }

    return pTmp;
}

//获取pstBsRoot之后的最小key所在位置
bsTree *bsGetMinNode(bsTree *pstBsRoot)
{
    bsTree *pTmp = pstBsRoot;

    if (NULL == pstBsRoot)
    {
        return NULL;    //子树不存在
    }

    while (NULL != pTmp->pLNode)
    {
        pTmp = pTmp->pLNode;
    }

    return pTmp;
}

bsTree* bsGetNext(bsTree *pNode)
{
    bsTree *pPer = NULL;    //父节点
    bsTree *pTmp = NULL;

    if (NULL != pNode->pRNode)
    {
        return bsGetMinNode(pNode->pRNode);     //右孩子存在,直接查找子树的最小key
    }

    /*
        如果pNode没有右孩子。则pNode有以下两种可能:
        (01) pNode是"一个左孩子",则"pNode的后继结点"为 "它的父结点"。
        (02) pNode是"一个右孩子",则查找"pNode的最低的父结点,并且该父结点要具有左孩子"
    */
    pTmp = pNode;
    pPer = pNode->pPNode;
    while ((NULL != pPer) && (pTmp == pPer->pRNode))   //父节点不为空且pNode是有孩子,查找pNode的父节点的具有左孩子的先祖
    {
        pTmp = pPer;
        pPer = pPer->pPNode;
    }

    return pPer;
}

bsTree* bsGetPre(bsTree *pNode)
{
    bsTree *pPer = NULL;    //父节点
    bsTree *pTmp = NULL;

    if (NULL != pNode->pLNode)
    {
        return bsGetMaxNode(pNode->pRNode);     //左孩子存在,直接查找子树的最大key
    }

    /*
        如果pNode没有左孩子。则pNode有以下两种可能:
        (01) pNode是"一个右孩子",则"pNode的后继结点"为 "它的父结点"。
        (02) pNode是"一个左孩子",则查找"pNode的父结点,并且该父结点要具有右孩子的父节点(不好用语言表述)"
    */
    pTmp = pNode;
    pPer = pNode->pPNode;
    while ((NULL != pPer) && (pTmp == pPer->pLNode))
    {
        pTmp = pPer;
        pPer = pPer->pPNode;
    }

    return pPer;
}

main.c

#include 
#include "bsTree.h"

bsTree *g_pstBsRoot = NULL;

//将i,转换成key,用于构造比较平衡的二叉树
int getKey(int i)
{
    switch (i)
    {
        case 0:
            return 3;
        case 1:
            return 2;
        case 2:
            return 4;
        case 3:
            return 8;
        case 4:
            return 7;
        case 5:
            return 11;
        case 6:
            return 9;
        case 7:
            return 12;
        case 8:
            return 10;
        case 9:
            return 11;
        default :
            return 1;
    }
}
void printBsTree(bsTree *pTreeRoot)
{
    if (NULL == pTreeRoot)
    {
        return;
    }

    printBsTree(pTreeRoot->pLNode);
    //访问根节点
    printf("%d\t", pTreeRoot->key);
    printBsTree(pTreeRoot->pRNode);

    return;
}

int main()
{
    bsTree *pTmp = NULL;
    bsTree *pNew = NULL;
    int i;
    int j;

    pNew = getBsNode(5);
    if (NULL == pNew)
    {
        exit(0);
    }

    pTmp = bsInsert(pNew, g_pstBsRoot);
    if (0 == pTmp)
    {
         exit(0);
    }
    g_pstBsRoot = pTmp;     //判断之后再赋值,防止插入失败导致根节点指向空,从而造成内存泄漏

    for (i = 0; i < 11; i++)
    {
        j = getKey(i);
        pNew = getBsNode(j);
        if (NULL == pNew)
        {
            exit(0);
        }

        pTmp = bsInsert(pNew, g_pstBsRoot);
        if (NULL == pTmp)
        {
             exit(0);
        }
        g_pstBsRoot = pTmp;
    }

    printBsTree(g_pstBsRoot);       //执行中序遍历之后,key按照从小到大的顺序排列

    pTmp = bsSearch(0, g_pstBsRoot);
    printf("\npTmp = %p", pTmp);      //打印key对应节点的位置

    pTmp = bsSearch(4, g_pstBsRoot);
    pTmp = bsGetPre(pTmp);     //获取4的前驱
    printf("\n%d", pTmp->key);
    pTmp = bsSearch(4, g_pstBsRoot);
    pTmp = bsGetNext(pTmp);     //获取4的后继
    printf("\n%d", pTmp->key);

    pTmp = bsSearch(1, g_pstBsRoot);
    pTmp = bsGetPre(pTmp);  //获取1的前驱,应该返回NULL
    printf("\npTmp = %p\n", pTmp);

    pTmp = bsSearch(5, g_pstBsRoot);
    g_pstBsRoot = bsDel(pTmp, g_pstBsRoot);
    printBsTree(g_pstBsRoot);       //执行中序遍历之后,key按照从小到大的顺序排列

    return 0;
}