排序二叉树节点的删除

全部代码

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

typedef struct node
{
    int nValue;
    struct node *pLeft;
    struct node *pRight;
}BiTree;

void Add(BiTree **ppRoot, int nNum)
{
    BiTree *pTemp = NULL;
    BiTree *pNode = NULL;

    assert(ppRoot!=NULL);

    //临时节点开辟空间
    pTemp = (BiTree *)malloc(sizeof(BiTree));
    if(NULL == pTemp)
    {
        printf("pTemp空间分配失败！
");
        exit(-1);
    }
    pTemp->nValue = nNum;
    pTemp->pLeft = NULL;
    pTemp->pRight = NULL;

    //空树
    if(NULL == *ppRoot)
    {
        *ppRoot = pTemp;
        return;
    }

    pNode = *ppRoot;

    //非空树
    while(pNode != NULL)
    {
        //比根大
        if(nNum > pNode->nValue)
        {
            //向右走
            if(NULL == pNode->pRight)
            {
                pNode->pRight = pTemp;
                return;
            }
            else
            {
                pNode = pNode->pRight;
            }
        }
        //比根小
        else if(nNum < pNode->nValue)
        {
            //向左走
            if(NULL == pNode->pLeft)
            {
                pNode->pLeft = pTemp;
                return;
            }
            else
            {
                pNode = pNode->pLeft;
            }
        }
        //相等  出错
        else
        {
            //释放临时节点空间
            free(pTemp);
            pTemp = NULL;
            return;
        }
    }
}

BiTree *CreateSBT(int arr[], int len)
{
    BiTree *pRoot = NULL;
    int i;

    assert(arr!=NULL && len>0);

    for(i=0; i<len; ++i)
    {
        Add(&pRoot, arr[i]);
    }

    return pRoot;
}

void BiTreeTraversal(BiTree *pRoot)
{
    if(NULL == pRoot)
    {
        return;
    }
    printf("%d ", pRoot->nValue);
    BiTreeTraversal(pRoot->pLeft);
    BiTreeTraversal(pRoot->pRight);
}

void FindNode(BiTree *pRoot, int nNum, BiTree **pDel, BiTree **pFather)
{
    assert(pRoot!=NULL && pDel!=NULL && pFather!=NULL);

    while(pRoot != NULL)
    {
        if(nNum == pRoot->nValue)
        {
            *pDel = pRoot;
            return;
        }
        else if(nNum < pRoot->nValue)
        {
            *pFather = pRoot;
            pRoot = pRoot->pLeft;
        }
        else
        {
            *pFather = pRoot;
            pRoot = pRoot->pRight;
        }
    }
}

void DelNode(BiTree **ppRoot, int nNum)
{
    BiTree *pDel = NULL;
    BiTree *pMark = NULL;
    BiTree *pFather = NULL;

    assert(*ppRoot!=NULL && ppRoot!=NULL);

    //查找
    FindNode(*ppRoot, nNum, &pDel, &pFather);

    //没找到
    if(NULL == pDel)
    {
        return;
    }

    //找到
    //检测节点情况
    //两个孩子
    while(pDel->pLeft!=NULL && pDel->pRight!=NULL)
    {
        //找到左的最右
        //先标记要删除节点
        pMark = pDel;

        //向左走一步
        pFather = pDel;
        pDel = pDel->pLeft;

        //最右
        while(pDel->pRight != NULL)
        {
            pFather = pDel;
            pDel = pDel->pRight;
        }

        //值覆盖
        pMark->nValue = pDel->nValue;
    }

    //一个孩子
    //被删除节点是根节点
    if(NULL == pFather)
    {
        *ppRoot = (*ppRoot)->pLeft?(*ppRoot)->pLeft : (*ppRoot)->pRight;
        free(pDel);
        pDel = NULL;
        return;
    }

    //被删除节点是父亲的左
    if(pDel == pFather->pLeft)
    {
        pFather->pLeft = pDel->pLeft?pDel->pLeft : pDel->pRight;
    }
    //被删除节点是父亲的右
    else
    {
        pFather->pRight = pDel->pRight?pDel->pRight : pDel->pLeft;
    }
    free(pDel);
    pDel = NULL;
}

int main(void)
{
    int arr[] = {1, 7, 3, 4, 5, 6, 7};
    int len = sizeof(arr)/sizeof(arr[0]);
    BiTree *pRoot = CreateSBT(arr, len);
    BiTreeTraversal(pRoot);
    printf("
");
    DelNode(&pRoot, 4);
    BiTreeTraversal(pRoot);

    return 0;
}