数据结构----二叉搜索树--递归（C语言）

上篇文章
二叉搜索树： https://blog.csdn.net/eric_qiushui/article/details/80516010
删除操作的代码过于冗长，我们考虑递归版本

---

1.BinarySearchTreeRecursion.h

#pragma once

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

typedef int DataType;

typedef struct BSTreeNode
{
    struct BSTreeNode *_pLeft;
    struct BSTreeNode *_pRight;
    DataType _data;
}BSTNode, *PBSTN;

void InitBSTreeRcs(PBSTN* pRoot);
PBSTN FindBSTreeRcs(PBSTN pRoot, DataType data);
void InsertBSTreeRcs(PBSTN* pRoot, DataType data);
void DeleteBSTreeRcs(PBSTN* pRoot, DataType data);
void InOrderRcs(PBSTN pRoot);
void DestroyBSTreeRcs(PBSTN* pRoot);

---

2.BinarySearchTreeRecursion.c

#include "BinarySearchTreeRecursion.h"


PBSTN BuyNewNodeRcs(data)
{
    PBSTN _new = (PBSTN)malloc(sizeof(BSTNode));

    if (_new == NULL)
    {
        assert(0);
        return NULL;
    }
    else
    {
        _new->_data = data;
        _new->_pLeft = NULL;
        _new->_pRight = NULL;
        return _new;
    }
}


void InitBSTreeRcs(PBSTN* pRoot)
{
    assert(pRoot);
    (*pRoot) = NULL;
}

PBSTN FindBSTreeRcs(PBSTN pRoot, DataType data)
{
    if (pRoot == NULL)
    {
        return NULL;
    }

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

void InsertBSTreeRcs(PBSTN* pRoot, DataType data)
{
    assert(pRoot);

    if ((*pRoot) == NULL)
    {
        (*pRoot) = BuyNewNodeRcs(data);
        return;
    }

    if ((*pRoot)->_data == data)
    {
        return;
    }
    else if (data < (*pRoot)->_data)
    {
        InsertBSTreeRcs(&((*pRoot)->_pLeft), data);
    }
    else
    {
        InsertBSTreeRcs(&((*pRoot)->_pRight), data);
    }
}

// 递归版本的删除只有删除根节点这一种情况
void DeleteBSTreeRcs(PBSTN* pRoot, DataType data)
{
    assert(pRoot);
    if (NULL == (*pRoot))
    {
        return;
    }

    if (data == (*pRoot)->_data)
    {
        PBSTN pDel = (*pRoot);
        if (NULL == (*pRoot)->_pLeft)
        { // 只有右孩子 || 叶子节点
            (*pRoot) = pDel->_pRight;
            free(pDel);
            pDel = NULL;
        }
        else if (NULL == (*pRoot)->_pRight)
        {  // 只有左孩子
            (*pRoot) = pDel->_pLeft;
            free(pDel);
            pDel = NULL;
        }
        else
        {
            pDel = (*pRoot)->_pRight;

            while (pDel->_pLeft)
            {
                pDel = pDel->_pLeft;
            }

            (*pRoot)->_data = pDel->_data;

            DeleteBSTreeRcs(&((*pRoot)->_pRight), pDel->_data);
        }
    }
    else if (data < (*pRoot)->_data)
    {
        DeleteBSTreeRcs(&((*pRoot)->_pLeft), data);
    }
    else
    {
        DeleteBSTreeRcs(&((*pRoot)->_pRight), data);
    }
}

void InOrderRcs(PBSTN pRoot)
{
    if (pRoot == NULL)
    {
        return;
    }

    InOrderRcs(pRoot->_pLeft);
    printf("%d ", pRoot->_data);
    InOrderRcs(pRoot->_pRight);
}

void DestroyBSTreeRcs(PBSTN* pRoot)
{
    assert(pRoot);

    if ((*pRoot) == NULL)
    {
        return;
    }

    DestroyBSTreeRcs(&(*pRoot)->_pLeft);
    DestroyBSTreeRcs(&(*pRoot)->_pRight);
    free(*pRoot);
    (*pRoot) = NULL;
}

---

3.test.c

#include "BinarySearchTreeRecursion.h"

void TestBinarySearchTree()
{
    PBSTN Root = NULL;
    int arr[] = { 5, 3, 4, 1, 7, 8, 2, 6, 0, 9 };
    int i = 0;
    int size = sizeof(arr) / sizeof(arr[0]);
    PBSTN ret_Find = NULL;

    InitBSTreeRcs(&Root);
    for (i = 0; i < size; i++)
    {
        InsertBSTreeRcs(&Root, arr[i]);
    }

    printf("InOrderRcs:");
    InOrderRcs(Root);
    printf("\n");

    InsertBSTreeRcs(&Root, 10);
    printf("InOrderRcs:");
    InOrderRcs(Root);
    printf("\n");

    ret_Find = FindBSTreeRcs(Root, 10);
    if (ret_Find == NULL)
    {
        printf("没找到！！！\n");
    }
    else
    {
        printf("找到了:%d\n", ret_Find->_data);
    }

    DeleteBSTreeRcs(&Root, 2);
    printf("InOrderRcs:");
    InOrderRcs(Root);
    printf("\n");

    DeleteBSTreeRcs(&Root, 1);
    printf("InOrderRcs:");
    InOrderRcs(Root);
    printf("\n");

    DeleteBSTreeRcs(&Root, 5);
    printf("InOrderRcs:");
    InOrderRcs(Root);
    printf("\n");


    DeleteBSTreeRcs(&Root, 3);
    printf("InOrderRcs:");
    InOrderRcs(Root);
    printf("\n");


    DestroyBSTreeRcs(&Root);
}

int main()
{
    TestBinarySearchTree();
    system("pause");
    return 0;
}

测试结果：

---

如有不正，还请指出，有劳！