二叉查找树

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

struct BSTNode
{
    int data;
    struct BSTNode *pLchild;
    struct BSTNode *pRchild;
    struct BSTNode *pParent;
};

void PreTraverseBSTree(struct BSTNode *pBST)
{
    if(NULL != pBST)
    {
        printf("数据为：%d，父节点地址为：%p\n",pBST ->data,pBST ->pParent);
        if(NULL != pBST ->pLchild )
            PreTraverseBSTree(pBST ->pLchild);
        if(NULL != pBST ->pRchild)
            PreTraverseBSTree(pBST ->pRchild);
    }
}

void InTraverseBSTree(struct BSTNode *pBST)
{
    if(NULL != pBST)
    {
        if(NULL != pBST ->pLchild )
            PreTraverseBSTree(pBST ->pLchild);
        printf("数据为：%d，父节点地址为：%p\n",pBST ->data,pBST ->pParent);
        if(NULL != pBST ->pRchild)
            PreTraverseBSTree(pBST ->pRchild);
    }
}

void PostTraverseBSTree(struct BSTNode *pBST)
{
    if(NULL != pBST)
    {
        if(NULL != pBST ->pLchild )
            PreTraverseBSTree(pBST ->pLchild);
        if(NULL != pBST ->pRchild)
            PreTraverseBSTree(pBST ->pRchild);
        printf("数据为：%d，父节点地址为：%p\n",pBST ->data,pBST ->pParent);
    }
}


struct BSTNode *SearchBSTree_v1(struct BSTNode *pBST,int key)  //版本1
{
    if(NULL == pBST || key == pBST ->data)
        return pBST;
    else if(key < pBST ->data)
        return SearchBSTree_v1(pBST ->pLchild,key);
    else return SearchBSTree_v1(pBST ->pRchild,key);
}

struct BSTNode *SearchBSTree_v2(struct BSTNode *pBST,int key)  //版本2
{
    while(NULL != pBST && key != pBST ->data)
    {
        if(key < pBST ->data)
            pBST = pBST ->pLchild;
        else pBST = pBST ->pRchild;
    }
    return pBST;
}

struct BSTNode *SearchMinBSTree(struct BSTNode *pBST,int *pMinData)//查找二叉搜索树中最小的值
{
    while(NULL != pBST ->pLchild)
    {
        pBST = pBST ->pLchild;
    }
    *pMinData = pBST ->data;
    return pBST;
}

struct BSTNode *SearchMaxBSTree(struct BSTNode *pBST,int *pMaxData) //查找二叉搜索树中最大的值
{
    while(NULL != pBST ->pRchild)
    {
        pBST = pBST ->pRchild;
    }
    *pMaxData = pBST ->data;
    return pBST;
}

void InsertBSTree(struct BSTNode *pBST,int InsertVal) //插入元素
{
    struct BSTNode *pRoot = pBST;//记录根节点地址
    struct BSTNode *pTmp =  NULL;
    struct BSTNode *pNew = (struct BSTNode *)malloc(sizeof(struct BSTNode));
    if(NULL == pNew)
        exit(-1);
    pNew ->data = InsertVal;
    pNew ->pLchild = pNew ->pRchild = NULL;
    while(NULL != pBST )
    {
        pTmp = pBST;
        if(pNew ->data < pBST ->data)
            pBST = pBST ->pLchild;
        else
            pBST = pBST ->pRchild;
    }
    pNew->pParent = pTmp;
    if(NULL == pTmp)  //当树为空时，将插入节点的地址赋给根节点
        *pRoot = *pNew;
    else if(pNew ->data <= pTmp ->data)
        pTmp ->pLchild = pNew;
    else
        pTmp ->pRchild = pNew;
}

void DeleteBSTree(struct BSTNode *pBST,int DeleteVal)
{
    struct BSTNode *pTem = SearchBSTree_v2(pBST,DeleteVal);
    if(pTem == NULL)
    {
        printf("没有找到要删除的元素！\n");
        exit(-1);
    }

    if(NULL == pTem ->pLchild && NULL == pTem ->pRchild) //删除节点无左右孩子
    {
        if(pTem == pTem ->pParent ->pLchild)  //删除节点是其父节点的左孩子
        {
            pTem ->pParent ->pLchild = NULL;
        }
        else              //删除节点是其父节点的右孩子
        {
            pTem ->pParent ->pRchild =NULL;
        }
        free(pTem);
        pTem = NULL;
    }

    else if(NULL == pTem ->pLchild)    //删除节点无左孩子
    {
        if(pTem == pTem ->pParent ->pLchild)  //删除节点为其父节点的左孩子
        {
            pTem ->pParent ->pLchild = pTem ->pRchild;
            pTem ->pRchild ->pParent = pTem ->pParent;
        }
        else                                 //删除节点为其父节点的右孩子
        {
            pTem ->pParent ->pRchild = pTem ->pRchild;
            pTem ->pRchild ->pParent = pTem ->pParent;
        }
        free(pTem);
        pTem = NULL;
    }

    else if(NULL == pTem ->pRchild) //删除节点无右孩子
    {
        if(pTem == pTem ->pParent->pLchild)  //删除节点为其父节点的左孩子
        {
            pTem ->pParent ->pLchild = pTem ->pLchild;
            pTem ->pLchild ->pParent = pTem ->pParent;
        }
        else   //删除节点为其父节点的右孩子
        {
            pTem ->pParent ->pRchild = pTem ->pLchild;
            pTem ->pLchild ->pParent = pTem ->pParent;
        }
        free(pTem);
        pTem = NULL;
    }
    else    //删除节点有左右孩子，用删除节点左字树中的最大值或者右子树中最小值来代替删除节点
            //本例中用右子树中最小值来代替
    {
        struct BSTNode *pTial = pTem ->pRchild;
        while(NULL != pTial ->pLchild)  //查找右子树中的最小值
        {
               pTial = pTial ->pLchild;
        }
        pTial ->pLchild = pTem ->pLchild;
        pTem ->pLchild ->pParent = pTial;

        if(pTem == pTem ->pParent ->pLchild)  //删除节点为其父节点的左孩子
        {
            pTem ->pParent ->pLchild = pTem ->pRchild;
            pTem ->pRchild ->pParent = pTem ->pParent;
        }
        else                                 //删除节点为其父节点的右孩子
        {
            pTem ->pParent ->pRchild = pTem ->pRchild;
            pTem ->pRchild ->pParent = pTem ->pParent;
        }

        free(pTem);
        pTem = NULL;
    }
}

struct BSTNode *CreateBSTree(void)
{
    struct BSTNode * pA = (struct BSTNode *)malloc(sizeof(struct BSTNode));
    if(NULL == pA)
        exit(-1);
    struct BSTNode * pB= (struct BSTNode *)malloc(sizeof(struct BSTNode));
    if(NULL == pB)
        exit(-1);
    struct BSTNode * pC= (struct BSTNode *)malloc(sizeof(struct BSTNode));
    if(NULL == pC)
        exit(-1);
    struct BSTNode * pD= (struct BSTNode *)malloc(sizeof(struct BSTNode));
    if(NULL == pD)
        exit(-1);
    struct BSTNode * pE= (struct BSTNode *)malloc(sizeof(struct BSTNode));
    if(NULL == pE)
        exit(-1);
    struct BSTNode * pF= (struct BSTNode *)malloc(sizeof(struct BSTNode));
    if(NULL == pF)
        exit(-1);
    struct BSTNode * pG= (struct BSTNode *)malloc(sizeof(struct BSTNode));
    if(NULL == pG)
        exit(-1);
    struct BSTNode * pH= (struct BSTNode *)malloc(sizeof(struct BSTNode));
    if(NULL == pH)
        exit(-1);
    struct BSTNode * pI= (struct BSTNode *)malloc(sizeof(struct BSTNode));
    if(NULL == pI)
        exit(-1);
    struct BSTNode * pJ= (struct BSTNode *)malloc(sizeof(struct BSTNode));
    if(NULL == pJ)
        exit(-1);
    struct BSTNode * pL= (struct BSTNode *)malloc(sizeof(struct BSTNode));
    if(NULL == pL)
        exit(-1);
    struct BSTNode * pN= (struct BSTNode *)malloc(sizeof(struct BSTNode));
    if(NULL == pN)
        exit(-1);

    pA ->data = 4;
    pB ->data = 2;
    pC ->data = 7;
    pD ->data = 3;
    pE ->data = 6;
    pF ->data = 13;
    pG ->data = 5;
    pH ->data = 10;
    pI ->data = 16;
    pJ ->data = 11;
    pL ->data = 1;
    pN ->data = 15;

    pA ->pLchild = pB;
    pA ->pRchild = pC;
    pB ->pLchild = pL;
    pB ->pRchild = pD;
    pC ->pLchild = pE;
    pC ->pRchild = pF;
    pE ->pLchild = pG;
    pE ->pRchild = NULL;
    pF ->pRchild = pI;
    pF ->pLchild = pH;
    pH ->pLchild = NULL;
    pH ->pRchild = pJ;
    pI ->pLchild = pN;
    pI ->pRchild = NULL;
    pJ ->pLchild = pJ ->pRchild =NULL;
    pN ->pLchild = pN ->pRchild =NULL;
    pD ->pLchild = pD ->pRchild = NULL;
    pL ->pLchild = pL ->pRchild = NULL;
    pG ->pLchild = pG ->pRchild = NULL;

    pA ->pParent = NULL;
    pB ->pParent = pA;
    pC ->pParent = pA;
    pD ->pParent = pB;
    pL ->pParent = pB;
    pE ->pParent = pC;
    pF ->pParent = pC;
    pG ->pParent = pE;
    pH ->pParent = pF;
    pI ->pParent = pF;
    pJ ->pParent = pH;
    pN ->pParent = pI;

    return pA;
}

int main()
{
    int MinData,MaxData;
    struct BSTNode *pRoot;
    pRoot=CreateBSTree();
    printf("先序遍历：\n");
    PreTraverseBSTree(pRoot);
    //printf("\n中序遍历：\n");
    //InTraverseBSTree(pRoot);
    //printf("\n后续遍历：\n");
    //PostTraverseBSTree(pRoot);
    printf("\n查找的元素为: key = 5");
    struct BSTNode *pKeyNode = SearchBSTree_v2(pRoot,5);
    if(NULL == pKeyNode)
        printf("查找失败!\n");
    else
        printf("\n查找成功，结点地址为：%p!",pKeyNode);
    struct BSTNode *pMinData = SearchMinBSTree(pRoot,&MinData);
    printf("\n最小值为：%d，其结点地址为：%p",MinData,pMinData);
    struct BSTNode *pMaxDate = SearchMaxBSTree(pRoot,&MaxData);
    printf("\n最大值为：%d，其结点地址为：%p",MaxData,pMaxDate);

    printf("\n插入的元素为: data = 12");
    InsertBSTree(pRoot,12); //插入元素
    printf("\n先序遍历：\n");
    PreTraverseBSTree(pRoot);

    DeleteBSTree(pRoot,13);
    printf("\n先序遍历：\n");
    PreTraverseBSTree(pRoot);
    return 0;
}