数据结构—搜索二叉树key-value模型（数据类型char*）

最新推荐文章于 2024-07-20 16:50:31 发布

原创最新推荐文章于 2024-07-20 16:50:31 发布 · 649 阅读

0 ·

CC 4.0 BY-SA版权

本文详细介绍了一种二叉搜索树的数据结构，并提供了创建、插入、查找和删除节点的算法实现。通过递归和非递归的方式，展示了如何在二叉搜索树中进行基本的操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

#include<malloc.h>
#include<assert.h>
#include<string.h>
typedef char* KeyType;
typedef char* ValueType;
typedef struct BSTreeNode
{
    struct BSTreeNode* _left;
    struct BSTreeNode* _right;
    KeyType _key;
    ValueType _value;
}BSTreeNode;

BSTreeNode* BuyBSTreeNode(KeyType key, ValueType value);//创建节点
int BSTreeInsertR(BSTreeNode** tree, KeyType key, ValueType value);//非递归插入
BSTreeNode* BSTreeFindR(BSTreeNode* tree, KeyType key);//非递归查找
int BSTreeRemoveR(BSTreeNode** tree, KeyType key);//非递归删除
void  BSTreeInOrder(BSTreeNode* tree);//递归中序遍历



BSTreeNode* BuyBSTreeNode(KeyType key, ValueType value)
{
    BSTreeNode* root = (BSTreeNode*)malloc(sizeof(BSTreeNode));
    assert(root);
    root->_left = NULL;
    root->_right = NULL;
    root->_key = key;
    root->_value = value;
    return root;
}


int BSTreeInsertR(BSTreeNode** tree, KeyType key, ValueType value)
{
    assert(tree);
    BSTreeNode* cur = *tree;
    BSTreeNode* pur = NULL;
    if (*tree == NULL)
    {
        *tree = BuyBSTreeNode(key, value);
        return 1;
    }
    while (cur)
    {

        if (strcmp(key, cur->_key) > 0)
        {
            pur = cur;
            cur = cur->_right;
        }
        else if (strcmp(key, cur->_key) == 0)
        {
            return -1;
        }
        else
        {
            pur = cur;
            cur = cur->_left;
        }
    }
    cur = BuyBSTreeNode(key, value);
    if (strcmp(key, pur->_key) > 0)
    {
        pur->_right = cur;
    }
    else
    {
        pur->_left = cur;
    }
    return 1;
}


BSTreeNode* BSTreeFindR(BSTreeNode* tree, KeyType key)
{
    assert(tree);
    BSTreeNode* cur = tree;
    while (cur)
    {
        if (strcmp(key, cur->_key) > 0)
        {
            cur = cur->_right;
        }
        else if (strcmp(key, cur->_key) == 0)
        {
            return cur;
        }
        else
        {
            cur = cur->_left;
        }
    }
    return NULL;
}


int BSTreeRemoveR(BSTreeNode** tree, KeyType key)
{
    assert(tree);
    BSTreeNode* de1;
    BSTreeNode* sub;
    BSTreeNode* cur = *tree;
    BSTreeNode* parant = *tree;
    if (cur == NULL)
    {
        return -1;
    }
    else
    {
        while (cur)
        {
            if (strcmp(key, cur->_key) < 0)
            {
                parant = cur;
                cur = cur->_left;
            }
            else if (strcmp(key, cur->_key) > 0)
            {
                parant = cur;
                cur = cur->_right;
            }
            else if (strcmp(key, cur->_key) == 0)
            {
                if (cur->_left == NULL && cur->_right)//左为空有，右不为空
                {
                    de1 = cur;
                    if (parant->_left == cur)
                    {
                        parant->_left = cur->_right;
                    }
                    else if (parant->_right == cur)
                    {
                        parant->_right = cur->_right;
                    }
                    else
                    {
                        *tree = cur->_right;
                    }
                    free(cur);
                    cur = NULL;
                    return 1;
                }
                else if (cur->_right == NULL && cur->_left)//左不为空，右为空
                {
                    if (parant->_left == cur)
                    {
                        parant->_left = cur->_left;
                    }
                    else if (parant->_right == cur)
                    {
                        parant->_right = cur->_left;
                    }
                    else
                    {
                        *tree = cur->_left;
                    }
                    free(cur);
                    cur = NULL;
                    return 1;
                }
                else if (cur->_left == NULL && cur->_right == NULL)//左右都为空
                {
                    if (parant->_left == cur)
                    {
                        parant->_left = NULL;
                    }
                    else if (parant->_right == cur)
                    {
                        parant->_right = NULL;
                    }
                    else
                    {
                        *tree = NULL;
                    }
                    free(cur);
                    cur = NULL;
                    return 1;
                }
                else//左和右均不为空
                {
                    sub = cur;
                    sub = cur->_left;
                    if (sub->_right == NULL)
                    {
                        cur->_key = sub->_key;
                        cur->_value = sub->_value;
                        cur->_left = sub->_left;
                        free(sub);
                        sub = NULL;
                        return 1;
                    }
                    else
                    {
                        de1 = sub;
                        while (de1->_right)
                        {
                            sub = de1;
                            de1 = de1->_right;
                        }
                        cur->_key = de1->_key;
                        cur->_value = de1->_value;
                        sub->_right = de1->_left;
                        free(de1);
                        de1 = NULL;
                        return 1;
                    }
                }
            }
        }
        return -1;
    }
}


void  BSTreeInOrder(BSTreeNode* tree)
{
    if (tree == NULL)
    {
        return;
    }
    else
    {
        BSTreeInOrder(tree->_left);
        printf("%s\n", tree->_value);
        BSTreeInOrder(tree->_right);
    }
}