二叉搜索树应用

1.判断一个单词是否拼写正确(递归)

//key模型
typedef char* KeyType;
typedef char* ValueType;

typedef struct BSTreeNode
{
    struct BSTreeNode* _left;
    struct BSTreeNode* _right;

    KeyType _key;
    ValueType _value;

}BSTreeNode;


BSTreeNode* BuyBSTreeNode(KeyType key);
int BSTreeInsertR(BSTreeNode** tree, KeyType key);
BSTreeNode* BSTreeFindR(BSTreeNode* tree, KeyType key);
int BSTreeRemoveR(BSTreeNode** tree, KeyType key);


BSTreeNode* BuyBSTreeNode(KeyType key)
{
    BSTreeNode* node = (BSTreeNode*)malloc(sizeof(BSTreeNode));
    assert(node);

    node->_key =key;
    node->_left = NULL;
    node->_right = NULL;
    return node;
}

int BSTreeInsertR(BSTreeNode** tree, KeyType key)
{

    if (*tree == NULL)
    {
        *tree = BuyBSTreeNode(key);
        return 0;
    }
    int ret = strcmp((*tree)->_key, key);
    if (ret>0)
    {
        return BSTreeInsertR(&(*tree)->_left, key);
    }
    else if (ret<0)
    {
        return BSTreeInsertR(&(*tree)->_right, key);
    }
    else
    {
        return -1;
    }
}


BSTreeNode* BSTreeFindR(BSTreeNode* tree, KeyType key)
{
    if (tree == NULL)
    {
        return NULL;
    }
    int ret = strcmp(tree->_key, key);
    if (ret>0)
    {
        return BSTreeFindR(tree->_left, key);//左子树
    }
    else if (ret<0)
    {
        return BSTreeFindR(tree->_right, key);
    }
    else
        return tree;//找到了
}


int BSTreeRemoveR(BSTreeNode** tree, KeyType key)
{
    if ((*tree) == NULL)
    {
        return -1;
    }
    int ret = strcmp((*tree)->_key, key);
    if (ret > 0)
    {
        return BSTreeRemoveR(&(*tree)->_left, key);
    }
    else if (ret < 0)
    {
        return BSTreeRemoveR(&(*tree)->_right, key);
    }
    else
    {
        //三种情况，左为空，右为空，左右均不为空
        BSTreeNode*cur = *tree;
        BSTreeNode*del = cur;
        if (cur->_left == NULL)
        {
            *tree = cur->_right;
        }
        else if (cur->_right == NULL)
        {
            *tree = cur->_left;
        }
        else
        {
            BSTreeNode* parent = cur;
            BSTreeNode* sub = cur->_right;
            while (sub->_left)
            {
                parent = sub;
                sub = sub->_left;
            }
            del = sub;
            cur->_key = sub->_key;

            if (parent->_left = sub)
            {
                parent->_left = sub->_right;
            }
            else
            {
                parent->_right = sub->_right;
            }
        }
            free(del);

        return 0;
    }
}

//测试用例
void TestBSTree()
{
    BSTreeNode *tree = NULL;

    BSTreeInsertR(&tree, "open");
    BSTreeInsertR(&tree, "door");
    BSTreeInsertR(&tree, "list");
    BSTreeInsertR(&tree, "hash");

    printf("%s\n", BSTreeFindR(tree, "open")->_key);
    printf("%s\n", BSTreeFindR(tree, "list")->_key);
    printf("%s\n", BSTreeFindR(tree, "hash")->_key);
    printf("%s\n", BSTreeFindR(tree, "door")->_key);

    printf("%p\n", BSTreeFindR(tree, "pppp"));
    printf("%p\n", BSTreeFindR(tree, "msdn"));

    BSTreeRemoveR(&tree, "hash");
    printf("%p\n", BSTreeFindR(tree, "hash"));

}

测试结果为：

2.请模拟实现一个简单的中英互译的字典

//key value模型

BSTreeNode* BuyBSTreeNode(KeyType key, ValueType value)
{
    BSTreeNode* node = (BSTreeNode*)malloc(sizeof(BSTreeNode));
    assert(node);

    node->_key = key;
    node->_value = value;
    node->_left = NULL;
    node->_right = NULL;
    return node;
}

int BSTreeInsertR(BSTreeNode** tree, KeyType key, ValueType value)
{

    if (*tree == NULL)
    {
        *tree = BuyBSTreeNode(key, value);
        return 0;
    }
    int ret = strcmp((*tree)->_key, key);
    if (ret>0)
    {
        return BSTreeInsertR(&(*tree)->_left, key,value);
    }
    else if (ret<0)
    {
        return BSTreeInsertR(&(*tree)->_right, key, value);
    }
    else
    {
        return -1;
    }
}

BSTreeNode* BSTreeFindR(BSTreeNode* tree, KeyType key)
{
    if (tree == NULL)
    {
        return NULL;
    }
    int ret = strcmp(tree->_key, key);
    if (ret>0)
    {
        return BSTreeFindR(tree->_left, key);//左子树
    }
    else if (ret<0)
    {
        return BSTreeFindR(tree->_right, key);
    }
    else
        return tree;//找到了
}


int BSTreeRemoveR(BSTreeNode** tree, KeyType key)
{
    if ((*tree) == NULL)
    {
        return -1;
    }
    int ret = strcmp((*tree)->_key, key);
    if (ret > 0)
    {
        return BSTreeRemoveR(&(*tree)->_left, key);
    }
    else if (ret < 0)
    {
        return BSTreeRemoveR(&(*tree)->_right, key);
    }
    else
    {
        //三种情况，左为空，右为空，左右均不为空
        BSTreeNode*cur = *tree;
        BSTreeNode*del = cur;
        if (cur->_left == NULL)
        {
            *tree = cur->_right;
        }
        else if (cur->_right == NULL)
        {
            *tree = cur->_left;
        }
        else
        {
            BSTreeNode* parent = cur;
            BSTreeNode* sub = cur->_right;
            while (sub->_left)
            {
                parent = sub;
                sub = sub->_left;
            }
            del = sub;
            cur->_key = sub->_key;

            if (parent->_left = sub)
            {
                parent->_left = sub->_right;
            }
            else
            {
                parent->_right = sub->_right;
            }

        }
        free(del);
        return 0;
    }
}


void TestBSTree1()
{
    BSTreeNode *tree = NULL;

    BSTreeInsertR(&tree, "open","开放");
    BSTreeInsertR(&tree, "door","门");
    BSTreeInsertR(&tree, "list","清单");
    BSTreeInsertR(&tree, "hash","哈希");

    printf("%s\n", BSTreeFindR(tree, "open")->_value);
    printf("%s\n", BSTreeFindR(tree, "list")->_value);
    printf("%s\n", BSTreeFindR(tree, "hash")->_value);
    printf("%s\n", BSTreeFindR(tree, "door")->_value);

    printf("%p\n", BSTreeFindR(tree, "pppp"));
    printf("%p\n", BSTreeFindR(tree, "msdn"));

    BSTreeRemoveR(&tree, "hash");
    printf("%p\n", BSTreeFindR(tree, "hash"));

}