二叉树的基本操作之增删查改

基本操作之头文件

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


typedef int DataType;
typedef struct BSTreeNode
{
    struct BSTreeNode* _pLeft;
    struct BSTreeNode* _pRight;
    DataType _data;
}Node, *PNode;


void InitBSTree(PNode* pRoot);//初始化二叉树
int InsertBST(PNode* pRoot, DataType data);//向二叉树中插入结点
PNode FindBST(PNode pRoot, DataType data);//查找结点
int DeleteBSTree(PNode* pRoot, int data);//删除结点
void InOrder(PNode pRoot);//中序遍历
PNode BuyBSTreeNode(DataType data);//创建结点
void DestroyBSTree(PNode* pRoot);//销毁二叉树

基本操作之函数实现

void InitBSTree(PNode* pRoot)
{
    assert(pRoot);
    *pRoot = NULL;
}

//插入结点
#if 0
int InsertBST(PNode* pRoot, DataType data)
{
    PNode pCur = NULL;
    PNode pParent = NULL;
    assert(pRoot);
    // 空树
    if(NULL == *pRoot)
        *pRoot = BuyBSTreeNode(data);

    // 找待插入元素的位置
    pCur = *pRoot;
    while(pCur)
    {
        if(data < pCur->_data)
        {
            pParent = pCur;
            pCur = pCur->_pLeft;
        }
        else if(data > pCur->_data)
        {
            pParent = pCur;
            pCur = pCur->_pRight;
        }
        else
            return 0;
    }

    // 插入新节点
    pCur = BuyBSTreeNode(data);
    if(data < pParent->_data)
        pParent->_pLeft = pCur;
    else
        pParent->_pRight = pCur;

    return 1;
}

//删除结点
int DeleteBSTree(PNode* pRoot, int data)//
{
    PNode pCur = NULL;
    PNode pDel = NULL;
    PNode pParent = NULL;
    assert(pRoot);
    if(NULL == *pRoot)
        return 0;

    // 找待删除节点的位置
    pCur = *pRoot;
    while(pCur)
    {
        if(data == pCur->_data)
            break;
        else if(data < pCur->_data)
        {
            pParent = pCur;
            pCur = pCur->_pLeft;
        }
        else
        {
            pParent = pCur;
            pCur = pCur->_pRight;
        }
    }

    if(NULL == pCur)
        return 0;

    // 删除
    // 只有左孩子 || 叶子结点
    if(NULL == pCur->_pRight)
    {
        pDel = pCur;
        // 删除根节点
        if(pCur == *pRoot)
            *pRoot = pCur->_pLeft;
        else
        {
            if(pCur == pParent->_pLeft)
                pParent->_pLeft = pCur->_pLeft;
            else
                pParent->_pRight = pCur->_pLeft;
        }
    }
    else if(NULL == pCur->_pLeft)
    {
        pDel = pCur;
        // 根节点：没有左子树  直接删除
        if(pCur == *pRoot)
            *pRoot = pCur->_pRight;
        else
        {
            if(pParent->_pLeft == pCur)
                pParent->_pLeft = pCur->_pRight;
            else
                pParent->_pRight = pCur->_pRight;
        }
    }
    else
    {
        // 左右孩子均存在
        pParent = pCur;
        pDel = pCur->_pRight;
        while(pDel->_pLeft)
        {
            pParent = pDel;
            pDel = pDel->_pLeft;
        }

        pCur->_data = pDel->_data;
        if(pDel == pParent->_pLeft)
            pParent->_pLeft = pDel->_pRight;
        else
            pParent->_pRight = pDel->_pRight;
    }

    free(pDel);
    return 1;
}

//查找结点
PNode FindBST(PNode pRoot, DataType data)
{
    PNode pCur = pRoot;
    while(pCur)
    {
        if(data == pCur->_data)
            return pCur;
        else if(data < pCur->_data)
            pCur = pCur->_pLeft;
        else
            pCur = pCur->_pRight;
    }

    return NULL;
}
#else

//递归式查找
PNode FindBST(PNode pRoot, DataType data)
{
    if(NULL == pRoot)
        return NULL;

    if(pRoot->_data == data)
        return pRoot;
    else if(data < pRoot->_data)
        return FindBST(pRoot->_pLeft, data);
    else
        return FindBST(pRoot->_pRight, data);
}

//递归式插入
int InsertBST(PNode* pRoot, DataType data)
{
    assert(pRoot);
    if(NULL == *pRoot)
    {
        *pRoot = BuyBSTreeNode(data);
        return 1;
    }
    else
    {
        if(data == (*pRoot)->_data)
            return 0;
        else if(data < (*pRoot)->_data)
            return InsertBST(&(*pRoot)->_pLeft, data);
        else
            return InsertBST(&(*pRoot)->_pRight, data);
    }
}

//递归式删除
int DeleteBSTree(PNode* pRoot, int data)
{
    assert(pRoot);
    if(NULL == *pRoot)
        return 0;
    else
    {
        if(data < (*pRoot)->_data)
            return DeleteBSTree(&(*pRoot)->_pLeft, data);
        else if(data > (*pRoot)->_data)
            return DeleteBSTree(&(*pRoot)->_pRight, data);
        else
        {
            // 待删除节点已经找到
            // 只有左子树 || 是叶子结点
            PNode pDel = *pRoot;
            if(NULL == (*pRoot)->_pRight)
            {
                *pRoot = pDel->_pLeft;
                free(pDel);
            }
            else if(NULL == (*pRoot)->_pLeft)
            {
                *pRoot = pDel->_pRight;
                free(pDel);
            }
            else
            {
                // 在右子树中找替代结点
                pDel = (*pRoot)->_pRight;
                while(pDel->_pLeft)
                    pDel = pDel->_pLeft;

                (*pRoot)->_data = pDel->_data;
                return DeleteBSTree(&(*pRoot)->_pRight, pDel->_data);
            }
        }
    }
}

#endif


void InOrder(PNode pRoot)
{
    if(pRoot)
    {
        InOrder(pRoot->_pLeft);
        printf("%d ", pRoot->_data);
        InOrder(pRoot->_pRight);
    }
}

PNode BuyBSTreeNode(DataType data)
{
    PNode pNewNode = (PNode)malloc(sizeof(Node));
    assert(pNewNode);
    pNewNode->_pLeft = NULL;
    pNewNode->_pRight = NULL;
    pNewNode->_data = data;

    return pNewNode;
}

基本操作之测试代码

void TestBSTree()
{
    int a [] = {5,3,4,1,7,8,2,6,0,9};
    PNode pRoot = NULL;
    PNode pCur;
    int i = 0;

    InitBSTree(&pRoot);//初始化二叉树
    for(; i < sizeof(a)/sizeof(a[0]); ++i)
        InsertBST(&pRoot, a[i]);

    InOrder(pRoot);//中序遍历

    pCur = FindBST(pRoot, 8);//找数值为8的结点
    if(pCur)
    {
        printf("8 Is In BSTree!!!\n");
    }
    else
        printf("8 Is Not In BSTree!!!\n");

    pCur = FindBST(pRoot, 10);
    if(pCur)
    {
        printf("10 Is In BSTree!!!\n");
    }
    else
        printf("10 Is Not In BSTree!!!\n");

    DeleteBSTree(&pRoot, 2);//删除数值为2的结点
    InOrder(pRoot);
    printf("\n");

    DeleteBSTree(&pRoot, 1);
    InOrder(pRoot);
    printf("\n");

    DeleteBSTree(&pRoot, 5);
    InOrder(pRoot);
    printf("\n");

    DeleteBSTree(&pRoot, 7);
    InOrder(pRoot);
    printf("\n");  

    DestroyBSTree(pRoot);//销毁二叉树

}