数据结构-二分搜索树(C语言实现)

导入头文件

编写代码过程中，涉及动态内存分配等常用的函数，需要引入如下头文件

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

结构体定义

// 定义二分搜索树中节点结构体
typedef struct Node
{
    int data;
    struct Node * left;
    struct Node * right;
} NODE, * PNODE;

函数声明

PNODE add(PNODE pNode, int val);      // 添加
void preTraverse(PNODE pNode);  // 前序
void inTraverse(PNODE pNode);   // 中序
void postTraverse(PNODE pNode); // 后序
PNODE min(PNODE pNode);  // 最小节点
PNODE max(PNODE pNode);  // 最大节点
PNODE removeMin(PNODE pNode);   // 删除最小节点
PNODE removeMax(PNODE pNode);   // 删除最大节点
PNODE removeNode(PNODE pNode, int val); // 删除节点

main函数

int main()
{
    //         3
    //   1           4
    //-1   2
    PNODE root = NULL; 
    root = add(root, 3);
    root = add(root, 1);
    root = add(root, 4);
    root = add(root, 2);
    root = add(root, -1);
    preTraverse(root);
//    removeMin(root);
//    removeMax(root);
    removeNode(root, 1);
    preTraverse(root);
    return 0;
}

添加节点

// 添加节点
PNODE add(PNODE pNode, int val)
{
    if (pNode==NULL)
    {
        PNODE pNew = (PNODE)malloc(sizeof(NODE));
        if (pNew==NULL)
        {
            printf("内存分配失败");
            exit(-1);
        }
        pNew->data = val;
        pNew->left = NULL;
        pNew->right = NULL;
        return pNew;
    } else {

        if (val<pNode->data)
        {
            pNode->left = add(pNode->left, val);
        }
        else if (val>pNode->data)
        {
            pNode->right = add(pNode->right, val);
        }
        return pNode;
    }
}

遍历

// 前序遍历
void preTraverse(PNODE pNode)
{
    if (pNode!=NULL)
    {
        printf("%d ", pNode->data);
        if (pNode->left!=NULL)
            preTraverse(pNode->left);
        if (pNode->right!=NULL)
            preTraverse(pNode->right);

    }
}

// 中序遍历
void inTraverse(PNODE pNode)
{
    if (pNode!=NULL)
    {
        if (pNode->left!=NULL)
            inTraverse(pNode->left);
        printf("%d ", pNode->data);
        if (pNode->right!=NULL)
            inTraverse(pNode->right);
    }
}

// 后序遍历
void postTraverse(PNODE pNode)
{
    if (pNode!=NULL)
    {
        if (pNode->left!=NULL)
            postTraverse(pNode->left);

        if (pNode->right!=NULL)
            postTraverse(pNode->right);
        printf("%d ", pNode->data);
    }
}

获取最小值

// 获取最小值的节点
PNODE min(PNODE pNode) {
    if (pNode == NULL)
        return NULL;
    if (pNode->left == NULL)
    {
        return pNode;
    }
    else
    {
        return min(pNode->left);
    }
}

获取最大值

// 获取最大值的节点
PNODE max(PNODE pNode) {
    if (pNode == NULL)
        return NULL;

    if (pNode->right == NULL)
    {
        return pNode;
    }
    else
    {
        return max(pNode->right);
    }
}

删除最小值

// 删除最小值的节点
PNODE removeMin(PNODE pNode) {
    if (pNode == NULL)
        return NULL;

    if (pNode->left == NULL)
    {
        PNODE rightNode = pNode->right;
        pNode = NULL;
        return rightNode;
    }
    pNode->left = removeMin(pNode->left);
    return pNode;
}

删除最大值

// 删除最大值的节点
PNODE removeMax(PNODE pNode) {
    if (pNode == NULL)
        return NULL;

    if (pNode->right == NULL)
    {
        PNODE leftNode = pNode->left;
        pNode = NULL;
        return leftNode;
    }
    pNode->right = removeMax(pNode->right);
    return pNode;
}

删除指定值

/**
 * 删除指定值节点
 * 1. 删除叶子节点
 * 2. 删除只有左子树或只有右子树节点
 * 3. 删除左右子树都有的节点
 */

PNODE removeNode(PNODE pNode, int val) {
    if (pNode == NULL)
    {
        return NULL;
    }
    if (val > pNode->data)
    {
        pNode->right = removeNode(pNode->right, val);
        return pNode;
    }
    else if (val < pNode->data)
    {
        pNode->left = removeNode(pNode->left, val);
        return pNode;
    }
    else
    {
        if (pNode->right == NULL)
        {
            PNODE leftNode = pNode->left;
            pNode = NULL;
            return leftNode;
        }

        if (pNode->left == NULL)
        {
            PNODE rightNode = pNode->right;
            pNode = NULL;
            return rightNode;
        }

        // 删除左右子树都有的节点
        PNODE successor = min(pNode->right);
        successor->right = removeMin(pNode->right);
        successor->left = pNode->left;

        pNode->left = NULL;
        pNode->right = NULL;
        return successor;
    }
}