二叉搜索树

最新推荐文章于 2025-05-19 10:07:58 发布
最新推荐文章于 2025-05-19 10:07:58 发布
阅读量265 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 数据结构 文章标签： 二叉搜索树 递归
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/adorable_/article/details/79548316

二叉搜索树概念

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树
  •若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
  •若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
  •它的左右子树也分别为二叉搜索树
如图所示：
二叉

二叉搜索树操作

1.插入
（1）如果这个树是空树，直接创建一个节点
（2）如果这个树是非空树
  a)先查找到一个合适的插入位置
  b)再在对应的位置上创建节点

插入

2.查找
（1）如果这个树是空树，查找失败
（2）如果这个树是非空树
  a)如果根节点key == 查找key，查找成功
  b)如果根节点key > 查找key，在左子树查找
  c)如果根节点key < 查找key，在右子树查找

查找

3.删除
（1）如果这个树是空树，直接返回
（2）如果这个树是非空树，找到要删除节点的位置，以及要删除节点的父节点
（3）如果要删除元素在树中没有找到，也直接返回
（4）如果要删除节点找到了，分情况讨论：
  a)要删除节点没有子树，直接删除该节点，并将该节点的父节点置空
  b)要删除节点，只有左子树，删除该节点的同时，将该节点的左子树挂到父节点上
  c)要删除节点，只有右子树，删除该节点的同时，将该节点的右子树挂到父节点上
  d)要删除节点，同时有左右子树，找到右子树中的最小值，然后将该最小值赋值给要删除的位置，然后再删除该右子树中的最小值节点，这样的节点最多只有一个右子树，就转换成了情况c)

删除

具体实现代码如下：

①search_tree.h

//实现二叉搜索树的递归和非递归版本

#pragma once 

typedef char SearchTreeType;

typedef struct SearchTreeNode {
    SearchTreeType key; // 关键码 
    struct SearchTreeNode* lchild;
    struct SearchTreeNode* rchild;
} SearchTreeNode;

void SearchTreeInit(SearchTreeNode** root);               //初始化

void SearchTreeInsert1(SearchTreeNode** root, SearchTreeType key);          //插入

void SearchTreeInsert2(SearchTreeNode** root, SearchTreeType key);          //插入(递归)

SearchTreeNode* SearchTreeFind1(SearchTreeNode* root,SearchTreeType to_find);          //查找

SearchTreeNode* SearchTreeFind2(SearchTreeNode* root, SearchTreeType to_find);          //查找(递归)

void SearchTreeRemove1(SearchTreeNode** root, SearchTreeType key);             //删除

void SearchTreeRemove2(SearchTreeNode** root, SearchTreeType key);             //删除(递归)

②search_tree.c

#include "search_tree.h"

#include <stdlib.h>

void SearchTreeInit(SearchTreeNode** root)              //初始化
{
    if (root == NULL)
    {
        return;          //非法输入
    }
    *root = NULL;
    return;
}

SearchTreeNode* CreateSearchTreeNode(SearchTreeType key)
{
    SearchTreeNode* new_node = (SearchTreeNode*)malloc(sizeof(SearchTreeNode));
    new_node->key = key;
    new_node->lchild = NULL;
    new_node->rchild = NULL;
    return new_node;
}

void SearchTreeInsert1(SearchTreeNode** root, SearchTreeType key)          //插入
{
    if (root == NULL)
    {
        return;        //非法输入
    }
    //1.如果这个树是空树，直接创建一个节点
    if (*root == NULL)
    {
        *root = CreateSearchTreeNode(key);
        return;
    }
    //2.如果这个树是非空树
    SearchTreeNode* cur = *root;
    SearchTreeNode* parent = NULL;
    while (1)
    {
        //  a)先查找到一个合适的插入位置
        if (cur == NULL)
        {
            break;        //合适的位置已找到
        }
        if (key < cur->key)
        {
            parent = cur;
            cur = cur->lchild;
        }
        else if (key > cur->key)
        {
            parent = cur;
            cur = cur->rchild;
        }
        else
        {
            return;          //约定当插入的值与当前元素相等时，插入失败
        }
    }
    //  b)再在对应的位置上创建节点
    SearchTreeNode* new_node = CreateSearchTreeNode(key);
    if (key < parent->key)
    {
        parent->lchild = new_node;
    }
    else
    {
        parent->rchild = new_node;
    }
    return;
}

void SearchTreeInsert2(SearchTreeNode** root, SearchTreeType key)          //插入(递归)
{
    if (root == NULL)
    {
        return;          //非法输入
    }
    //1.先找到在哪个位置插入
    //2.创建新的节点，放在对应位置上
    if (*root == NULL)
    {
        *root = CreateSearchTreeNode(key);
        return;
    }
    if (key < (*root)->key)
    {
        SearchTreeInsert2(&(*root)->lchild, key);
        return;
    }
    else if (key > (*root)->key)
    {
        SearchTreeInsert2(&(*root)->rchild, key);
        return;
    }
    else
    {
        return;      //插入失败
    }
}

SearchTreeNode* SearchTreeFind1(SearchTreeNode* root, SearchTreeType to_find)          //查找
{
    if (root == NULL)
    {
        return;       //非法输入
    }
    SearchTreeNode* cur = root;
    while (cur != NULL)
    {
        if (to_find < cur->key)
        {
            cur = cur->lchild;
        }
        else if (to_find > cur->key)
        {
            cur = cur->rchild;
        }
        else
        {
            break;
        }
    }
    return cur;
}

SearchTreeNode* SearchTreeFind2(SearchTreeNode* root, SearchTreeType to_find)          //查找(递归)
{
    if (root == NULL)
    {
        return NULL;        //非法输入
    }
    if (to_find < root->key)
    {
        SearchTreeFind2(root->lchild, to_find);
    }
    else if (to_find > root->key)
    {
        SearchTreeFind2(root->rchild, to_find);
    }
    else
    {
        return root;
    }
}

void DestroySearchTreeNode(SearchTreeNode* to_remove)
{
    free(to_remove);
}
void SearchTreeRemove1(SearchTreeNode** root, SearchTreeType key)             //删除
{
    if (root == NULL)
    {
        return;        //非法输入
    }
    //1.处理空树情况，直接返回
    if (*root == NULL)
    {
        return;
    }
    SearchTreeNode* to_remove = *root;
    SearchTreeNode* parent = NULL;
    //2.找到要删除节点的位置，以及要删除节点的父节点
    while (to_remove != NULL)
    {
        if (key < to_remove->key)
        {
            parent = to_remove;
            to_remove = to_remove->lchild;
        }
        else if (key > to_remove->key)
        {
            parent = to_remove;
            to_remove = to_remove->rchild;
        }
        else
        {
            break;
        }
    }
    //3.如果要删除元素在树中没有找到，也直接返回
    if (to_remove == NULL)
    {
        return;
    }
    //4.如果要删除节点找到了，分情况讨论：
    //     a)要删除节点没有子树，直接删除该节点，并将该节点的父节点置空
    if (to_remove->lchild == NULL && to_remove->rchild == NULL)
    {
        if (to_remove == *root)
        {
            //要删除的是根节点
            *root = NULL;
        }
        else
        {
            if (parent->lchild == to_remove)
            {
                parent->lchild = NULL;
            }
            else
            {
                parent->rchild = NULL;
            }
            DestroySearchTreeNode(to_remove);
            return;
        }
    }
    //     b)要删除节点，只有左子树，删除该节点的同时，将该节点的左子树挂到父节点上
    else if(to_remove->lchild != NULL && to_remove->rchild == NULL)
    {
        if (to_remove == *root)
        {
            //要删除的是根节点
            *root = to_remove->lchild;
            DestroySearchTreeNode(to_remove);
        }
        else
        {
            if (to_remove == parent->lchild)
            {
                parent->lchild = to_remove->lchild;
            }
            else
            {
                parent->rchild = to_remove->lchild;
            }
            DestroySearchTreeNode(to_remove);
            return;
        }
    }
    //     c)要删除节点，只有右子树，删除该节点的同时，将该节点的右子树挂到父节点上
    else if (to_remove->lchild == NULL && to_remove->rchild != NULL)
    {
        if (to_remove == *root)
        {
            //要删除的是根节点
            *root = to_remove->rchild;
            DestroySearchTreeNode(to_remove);
        }
        else
        {
            if (to_remove == parent->lchild)
            {
                parent->lchild = to_remove->rchild;
            }
            else
            {
                parent->rchild = to_remove->rchild;
            }
            DestroySearchTreeNode(to_remove);
            return;
        }
    }
    //     d)要删除节点，同时有左右子树，找到右子树中的最小值，
    //       然后将该最小值赋值给要删除的位置，然后再删除该右子树中的最小值节点，
    //       这样的节点最多只有一个右子树，就转换成了情况c)
    else
    {
        SearchTreeNode* min = to_remove->rchild;
        SearchTreeNode* min_parent = to_remove;
        while (min->lchild != NULL)
        {
            min_parent = min;
            min = min->lchild;
        }
        //代码执行到这里，min就已经指向to_remove右子树的最小值
        to_remove->key = min->key;
        if (min_parent->lchild == min)
        {
            min_parent->lchild = min->rchild;
        }
        else
        {
            min_parent->rchild = min->rchild;
        }
        DestroySearchTreeNode(min);
        return;
    }
}

void SearchTreeRemove2(SearchTreeNode** root, SearchTreeType key)             //删除(递归)
{
    if (root == NULL)
    {
        return;     //非法输入
    }
    //1.处理空树情况，直接返回
    if (*root == NULL)
    {
        return;
    }
    //2.如果没找到的话，不需要进行任何删除动作
    if (key < (*root)->key)
    {
        SearchTreeRemove2(&(*root)->lchild, key);
        return;
    }
    else if (key>(*root)->key)
    {
        SearchTreeRemove2(&(*root)->rchild, key);
        return;
    }
    //3.找到后分情况讨论：
    else
    {
        SearchTreeNode* to_remove = *root;
        //     a)要删除节点没有子树，直接删除该节点，并将该节点的父节点置空
        if (to_remove->lchild == NULL && to_remove->rchild == NULL)
        {
            *root = NULL;
            DestroySearchTreeNode(to_remove);
            return;
        }
        //     b)要删除节点，只有左子树，删除该节点的同时，将该节点的左子树挂到父节点上
        else if (to_remove->lchild != NULL && to_remove->rchild == NULL)
        {
            *root = to_remove->lchild;
            DestroySearchTreeNode(to_remove);
            return;
        }
        //     c)要删除节点，只有右子树，删除该节点的同时，将该节点的右子树挂到父节点上
        else if (to_remove->lchild == NULL && to_remove->rchild != NULL)
        {
            *root = to_remove->rchild;
            DestroySearchTreeNode(to_remove);
            return;
        }
        //     d)要删除节点，同时有左右子树，找到右子树中的最小值，
        //       然后将该最小值赋值给要删除的位置，然后再删除该右子树中的最小值节点，
        //       这样的节点最多只有一个右子树，就转换成了情况c)
        else
        {
            SearchTreeNode* min = to_remove->rchild;
            while (min->lchild != NULL)
            {
                min = min->lchild;
            }
            //代码执行到这里，min就已经指向to_remove右子树的最小值
            to_remove->key = min->key;
            SearchTreeRemove2(&to_remove->rchild, min->key);
            return;
        }
    }
}

③test.c

#include "search_tree.h"

#include <stdio.h>
#include <windows.h>

#define TEST_HEADER printf("\n===========================%s====================\n",__FUNCTION__)

void TestInit()
{
    TEST_HEADER;
    SearchTreeNode* root;
    SearchTreeInit(&root);
    printf("root except NULL,actual %p\n", root);
}

void PreOrder(SearchTreeNode* root)
{
    if (root == NULL)
    {
        return;
    }
    printf("%c ", root->key);
    PreOrder(root->lchild);
    PreOrder(root->rchild);
    return;
}

void InOrder(SearchTreeNode* root)
{
    if (root == NULL)
    {
        return;
    }
    InOrder(root->lchild);
    printf("%c ", root->key);
    InOrder(root->rchild);
    return;
}

void TestInsert1()
{
    TEST_HEADER;
    SearchTreeNode* root;
    SearchTreeInit(&root);
    SearchTreeInsert1(&root, 'd');
    SearchTreeInsert1(&root, 'h');
    SearchTreeInsert1(&root, 'f');
    SearchTreeInsert1(&root, 'a');
    SearchTreeInsert1(&root, 'l');
    SearchTreeInsert1(&root, 'e');
    SearchTreeInsert1(&root, 'c');
    printf("[先序遍历结果]：");
    PreOrder(root);
    printf("\n");
    printf("[中序遍历结果]：");
    InOrder(root);
    printf("\n");
}

void TestInsert2()
{
    TEST_HEADER;
    SearchTreeNode* root;
    SearchTreeInit(&root);
    SearchTreeInsert2(&root, 'd');
    SearchTreeInsert2(&root, 'h');
    SearchTreeInsert2(&root, 'f');
    SearchTreeInsert2(&root, 'a');
    SearchTreeInsert2(&root, 'l');
    SearchTreeInsert2(&root, 'e');
    SearchTreeInsert2(&root, 'c');
    printf("[先序遍历结果]：");
    PreOrder(root);
    printf("\n");
    printf("[中序遍历结果]：");
    InOrder(root);
    printf("\n");
}

void TestFind1()
{
    TEST_HEADER;
    SearchTreeNode* root;
    SearchTreeInit(&root);
    SearchTreeInsert1(&root, 'd');
    SearchTreeInsert1(&root, 'h');
    SearchTreeInsert1(&root, 'f');
    SearchTreeInsert1(&root, 'a');
    SearchTreeInsert1(&root, 'l');
    SearchTreeInsert1(&root, 'e');
    SearchTreeInsert1(&root, 'c');

    SearchTreeNode* ret = SearchTreeFind1(root, 'f');
    printf("查找f：ret expect %p,actual %p\n", root->rchild->lchild, ret);

    ret = SearchTreeFind1(root, 'c');
    printf("查找c：ret expect %p,actual %p\n", root->lchild->rchild, ret);
}

void TestFind2()
{
    TEST_HEADER;
    SearchTreeNode* root;
    SearchTreeInit(&root);
    SearchTreeInsert1(&root, 'd');
    SearchTreeInsert1(&root, 'h');
    SearchTreeInsert1(&root, 'f');
    SearchTreeInsert1(&root, 'a');
    SearchTreeInsert1(&root, 'l');
    SearchTreeInsert1(&root, 'e');
    SearchTreeInsert1(&root, 'c');

    SearchTreeNode* ret = SearchTreeFind2(root, 'f');
    printf("查找f：ret expect %p,actual %p\n", root->rchild->lchild, ret);

    ret = SearchTreeFind2(root, 'c');
    printf("查找c：ret expect %p,actual %p\n", root->lchild->rchild, ret);
}

void TestRemove1()
{
    TEST_HEADER;
    SearchTreeNode* root;
    SearchTreeInit(&root);
    SearchTreeInsert1(&root, 'd');
    SearchTreeInsert1(&root, 'h');
    SearchTreeInsert1(&root, 'f');
    SearchTreeInsert1(&root, 'a');
    SearchTreeInsert1(&root, 'l');
    SearchTreeInsert1(&root, 'e');
    SearchTreeInsert1(&root, 'c');
    printf("[先序遍历结果]：");
    PreOrder(root);
    printf("\n");
    printf("[中序遍历结果]：");
    InOrder(root);
    printf("\n");

    SearchTreeRemove1(&root, 'h');
    printf("删除h后：\n");
    printf("[先序遍历结果]：");
    PreOrder(root);
    printf("\n");
    printf("[中序遍历结果]：");
    InOrder(root);
    printf("\n");

    SearchTreeRemove1(&root, 'd');
    printf("删除d后：\n");
    printf("[先序遍历结果]：");
    PreOrder(root);
    printf("\n");
    printf("[中序遍历结果]：");
    InOrder(root);
    printf("\n");

    SearchTreeRemove1(&root, 'c');
    printf("删除c后：\n");
    printf("[先序遍历结果]：");
    PreOrder(root);
    printf("\n");
    printf("[中序遍历结果]：");
    InOrder(root);
    printf("\n");
}

void TestRemove2()
{
    TEST_HEADER;
    SearchTreeNode* root;
    SearchTreeInit(&root);
    SearchTreeInsert1(&root, 'd');
    SearchTreeInsert1(&root, 'h');
    SearchTreeInsert1(&root, 'f');
    SearchTreeInsert1(&root, 'a');
    SearchTreeInsert1(&root, 'l');
    SearchTreeInsert1(&root, 'e');
    SearchTreeInsert1(&root, 'c');
    printf("[先序遍历结果]：");
    PreOrder(root);
    printf("\n");
    printf("[中序遍历结果]：");
    InOrder(root);
    printf("\n");

    SearchTreeRemove2(&root, 'h');
    printf("删除h后：\n");
    printf("[先序遍历结果]：");
    PreOrder(root);
    printf("\n");
    printf("[中序遍历结果]：");
    InOrder(root);
    printf("\n");

    SearchTreeRemove2(&root, 'd');
    printf("删除d后：\n");
    printf("[先序遍历结果]：");
    PreOrder(root);
    printf("\n");
    printf("[中序遍历结果]：");
    InOrder(root);
    printf("\n");

    SearchTreeRemove2(&root, 'c');
    printf("删除c后：\n");
    printf("[先序遍历结果]：");
    PreOrder(root);
    printf("\n");
    printf("[中序遍历结果]：");
    InOrder(root);
    printf("\n");
}

int main()
{
    TestInit();
    TestInsert1();
    TestInsert2();
    TestFind1();
    TestFind2();
    TestRemove1();
    TestRemove2();
    system("pause");
    return 0;
}

测试结果如下图所示：

结果
结果

二叉搜索树性能分析

  插入和删除操作都必须先查找，查找效率代表二叉搜索树中各个操作的性能。
  对有n个节点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是节点在二叉搜索树的深度的函数，即节点越深，则比较次数越多
  但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树，如：

性能

二叉查找树
程笙羽的博客
11-27 178
二叉树的特殊性质可以让查找方式更加迅速。利用二叉查找树的性质，进行查找，插入，删除操作，来提高算法的整体效率
二叉树-二叉查找树
编程使我快乐
06-15 859
1.树 1.1 有关树的易混概念
二叉树搜索
weixin_34122810的博客
07-07 128
删除数值一般来说，须要依据以下几种情况分别进行处理： 1.须要删除的节点没有左儿子，那么把右儿子提上去 2.须要删除的节点的左儿子没有右儿子，那么就把左儿子提上去 3.以上两种情况都不满足的话，就把左儿子的子孙中最大的节点提到须要删除的节点上 和堆一样。非常多情况下不须要自己实现二叉搜索树，使用C++中的STL，STL里有set和map容器， set是使用erc搜索树维护集合的容器，而...
二叉查找树（BST）
最新发布
小瑾的博客
05-19 1190
二叉查找树（BST）是一种特殊的二叉树，其每个节点的左子树值小于该节点，右子树值大于该节点。BST的基本操作包括查找、插入和删除，其中删除操作较为复杂，需根据节点子节点数量采取不同策略。BST的性能在平衡情况下为O(logn)，但在最坏情况下可能退化为O(n)。BST的扩展应用包括AVL树、红黑树、伸展树和Treap等，它们通过不同机制保持树的平衡。
搜索二叉树
宇哲
10-21 1857
二叉搜索树：它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。二叉搜索树有个特点，最左的是最小的节点，最右的是最大的节点。 当我们把二叉搜索树进行中序遍历的时候，它是进行排序后的结果，所以我们也把二叉搜索树叫做排序二叉树。接下来我们介绍二叉
Java创建二叉搜索树,实现搜索,插入,删除的操作实例
08-28
Java 创建二叉搜索树、实现搜索、插入、删除的操作实例 Java 创建二叉搜索树是指通过 Java 语言实现一个二叉搜索树数据结构，该树具有查找、插入、删除等操作的功能。二叉搜索树是一种特殊的二叉树，每个节点的值...
c代码-二叉搜索树的删除操作
07-14
在IT领域，二叉搜索树（Binary Search Tree，简称BST）是一种常见的数据结构，它具有很多优秀的特性，比如快速的查找、插入和删除操作。在实际应用中，我们经常需要对BST进行各种操作，其中删除操作是相对复杂的一个...
树-98. 验证二叉搜索树-PYTHON
01-20
在二叉搜索树（Binary Search Tree，BST）中，每个节点的值必须满足以下规则：对于任意节点，其左子树中的所有节点的值都小于该节点的值，而其右子树中的所有节点的值都大于该节点的值。在给定的题目“树-98. 验证...
Python实现二叉搜索树BST的方法示例
09-18
二叉搜索树（BST，Binary Search Tree），又称为二叉查找树或二叉排序树，是一种特殊的二叉树数据结构，其每个节点的值满足以下条件： 1. 节点的左子树中所有节点的值都小于该节点的值。 2. 节点的右子树中所有节点...
二叉查找树(Binary Search Tree)
WeiJun的专栏
07-19 866
二叉查找树（英语：Binary Search Tree），也称二叉搜索树、有序二叉树（英语：ordered binary tree），排序二叉树（英语：sorted binary tree），是指一棵空树或者具有下列性质的二叉树： 若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 任意节
java 如何卸载qq_java二叉树删除如何操作？
weixin_28946193的博客
02-16 188
今天所讲的是二叉树的删除，小伙伴们点进来，肯定是对二叉树有说了解的吧啊，首先学习二叉树删除，建议先了解诶二叉树的建立，遍历，插入和查找，以便小伙伴们能够很好的掌握今天小编所讲的内容，接下来让我们一起来了解下吧。二叉树的删除操作是比较复杂的。首先要找到删除的节点。要删除的结点对象并不一定要进行删除操作。因为通过函数调用得到的只是他的副本。并不会真正的把他删掉。你只要让他不在树上就行了。让删除结点的父...
二叉搜索树中的搜索算法详解
根据给定的信息，我们可以确定本篇知识点的核心集中在二叉搜索树（Binary Search Tree，简称BST）以及在二叉搜索树中进行搜索的相关内容。为了满足字数要求并提供丰富的信息，下面将对二叉搜索树的概念、特点、搜索...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值