二叉搜索树

代码

---

• BSTree.h

#pragma once

#ifndef _BSTREE_H_
#define _BSTREE_H_

typedef int DataType;

typedef struct BSTree
{
    struct BSTree* _pLeft;
    struct BSTree* _pRight;
    DataType _data;
}BSTNode,*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);
void DestroyBSTree(PNode* pRoot);
PNode BuyBSTreeNode(DataType data);

//递归
int InsertBST_d(PNode* pRoot, DataType data);
PNode FindBST_d(PNode pRoot, DataType data);
int DeleteBSTree_d(PNode* pRoot, int data);

#endif // !_BSTREE_H_

• BSTree.c

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

PNode BuyBSTreeNode(DataType data)
{
    PNode pNewNode = (PNode)malloc(sizeof(BSTNode));
    pNewNode->_data = data;
    pNewNode->_pLeft = NULL;
    pNewNode->_pRight = NULL;
    return pNewNode;
}

void InitBSTree(PNode* pRoot)//初始化
{
    assert(pRoot);
    (*pRoot) = NULL;

}


int InsertBST(PNode* pRoot, DataType data)//插入
{
    assert(pRoot);
    if (NULL == *pRoot)
    {
        (*pRoot) = BuyBSTreeNode(data);
        return 1;
    }

    PNode pCur = (*pRoot);
    PNode pParent = NULL;

    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(pCur->_data < pParent->_data)
        pParent->_pLeft = pCur;
    else 
        pParent->_pRight = pCur;
    return 1;
}


PNode FindBST(PNode pRoot, DataType data)//搜索
{
    assert(pRoot);

    PNode pCur = pRoot;
    while (pCur)
    {
        if (data < pCur->_data)
            pCur = pCur->_pLeft;
        else if (data > pCur->_data)
            pCur = pCur->_pRight;
        else
            return pCur;
    }
    return NULL;
}

int DeleteBSTree(PNode* pRoot, int data)//在二叉搜索树中删除data元素
{
    PNode pCur = *pRoot;
    PNode pParent = NULL;
    PNode pDel = NULL;

    //首先定位
    while (pCur)
    {
        if (data < pCur->_data)
        {
            pParent = pCur;
            pCur = pCur->_pLeft;
        }
        else if (data > pCur->_data)
        {
            pParent = pCur;
            pCur = pCur->_pRight;
        }
        else break;
    }

    if (pCur)//如果pCur不为空，即已经确定pCur的位置，开始删除
    {
        pDel = pCur;
        //1.pCur无孩子 || 只有左孩子
        if (NULL == pCur->_pRight)
        {
            if (pCur == (*pRoot))//如果pCur为根结点
            {
                (*pRoot)= pCur->_pLeft;
            }

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

        //2.pCur只有右孩子
        else if (NULL == pCur->_pLeft)
        {
            if (pCur == (*pRoot))//如果pCur为根结点
            {
                (*pRoot) = pCur->_pRight;
            }
            else
            {
                if (pParent->_pLeft == pCur)
                    pParent->_pLeft = pCur->_pRight;
                else
                    pParent->_pRight = pCur->_pRight;
            }
        }

        //3.pCur即有左孩子也有右孩子
        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);

    }

}

void InOrder(PNode pRoot)//前序遍历
{
    if (pRoot)
    {
        InOrder(pRoot->_pLeft);
        printf("%d ", pRoot->_data);
        InOrder(pRoot->_pRight);
    }
}
void DestroyBSTree(PNode* pRoot)//销毁
{
    if (*pRoot)
    {
        DestroyBSTree(&(*pRoot)->_pLeft);
        DestroyBSTree(&(*pRoot)->_pRight);
        free(*pRoot);
    }
}

void Test()
{
    PNode pRoot;
    int arr[] = { 5,3,4,1,7,8,2,6,0,9 };
    //初始化
    InitBSTree(&pRoot);

    //插入
    for (int i = 0; i < 10; i++)
    {
        InsertBST(&pRoot, arr[i]);
    }
    InOrder(pRoot);
    printf("\n");

    //查询测试
    PNode Find = NULL;
    Find = FindBST(pRoot, 2);
    if(Find)
        printf("%d Is In BSTree!!!\n", Find->_data);
    else 
        printf("%d Is In BSTree!!!\n", 2);

    Find = FindBST(pRoot, 10);
    if (Find)
        printf("%d Is In BSTree!!!\n", Find->_data);
    else
        printf("%d Is Not In BSTree!!!\n", 10);

    //删除测试
    DeleteBSTree(&pRoot, 0);
    DeleteBSTree(&pRoot, 1);
    DeleteBSTree(&pRoot, 2);
    DeleteBSTree(&pRoot, 3);
    DeleteBSTree(&pRoot, 4);
    DeleteBSTree(&pRoot, 5);
    InOrder(pRoot);
    printf("\n");



    DestroyBSTree(&pRoot);//销毁测试
    system("pause");
    return 0;
}

• BSTree_D.c

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

//递归
int InsertBST_d(PNode* pRoot, DataType data)
{
    if (NULL == *pRoot)
    {
        (*pRoot) = BuyBSTreeNode(data);
        return 1;
    }

    if (data < (*pRoot)->_data)
        return InsertBST_d(&(*pRoot)->_pLeft, data);
    else if (data > (*pRoot)->_data)
        return InsertBST_d(&(*pRoot)->_pRight, data);
    else
        return 0;

}

PNode FindBST_d(PNode pRoot, DataType data)
{
    if (NULL == pRoot)
    {
        return NULL;
    }

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

int DeleteBSTree_d(PNode* pRoot, int data)
{
    if (*pRoot == NULL)
        return 0;
    if (data < (*pRoot)->_data)
        DeleteBSTree_d(&(*pRoot)->_pLeft, data);
    else if (data > (*pRoot)->_data)
        DeleteBSTree_d(&(*pRoot)->_pRight, data);
    else
    {
        PNode pDel = *pRoot;
        if (NULL == (*pRoot)->_pRight)
        {
            (*pRoot) = (*pRoot)->_pLeft;
            free(pDel);
        }
        else if (NULL == pDel->_pLeft)
        {
            (*pRoot) = (*pRoot)->_pRight;
            free(pDel);
        }
        else
        {
            pDel = (*pRoot)->_pRight;
            while (pDel->_pLeft)
            {
                pDel = pDel->_pLeft;
            }
            (*pRoot)->_data = pDel->_data;
            DeleteBSTree_d(&(*pRoot)->_pRight, pDel->_data);
        }
    }
}


void Test_d()
{
    PNode pRoot;
    int arr[] = { 5,3,4,1,7,8,2,6,0,9 };
    //初始化
    InitBSTree(&pRoot);

    //插入
    for (int i = 0; i < 10; i++)
    {
        InsertBST_d(&pRoot, arr[i]);
    }
    InOrder(pRoot);
    printf("\n");

    //查询测试
    PNode Find = NULL;
    Find = FindBST_d(pRoot, 2);
    if (Find)
        printf("%d Is In BSTree!!!\n", Find->_data);
    else
        printf("%d Is In BSTree!!!\n", 2);

    Find = FindBST_d(pRoot, 10);
    if (Find)
        printf("%d Is In BSTree!!!\n", Find->_data);
    else
        printf("%d Is Not In BSTree!!!\n", 10);

    //删除测试
    DeleteBSTree_d(&pRoot, 0);
    DeleteBSTree_d(&pRoot, 1);
    DeleteBSTree_d(&pRoot, 2);
    DeleteBSTree_d(&pRoot, 3);
    DeleteBSTree_d(&pRoot, 4);
    DeleteBSTree_d(&pRoot, 5);
    InOrder(pRoot);
    printf("\n");


    DestroyBSTree(&pRoot);//销毁测试
    system("pause");
    return 0;
}