二叉查找树

最新推荐文章于 2025-09-10 15:24:29 发布
最新推荐文章于 2025-09-10 15:24:29 发布
阅读量77 收藏
点赞数
文章标签： 数据结构与算法

二叉查找树又称二叉排序树，所有节点均满足左子节点键值小于其根节点；右子节点的键值大于其根节点；不存在两节点关键字相同的二叉树称为二叉查找树。空树也是二叉查找树。

由相同的节点生成的二叉查找树不唯一，最好的情况是生成平衡二叉树而最坏的情况是生成单支二叉树（实际上是线性链表）。在随机的情况下，二叉查找树的平均查找长度为O（log n），若想建立可以实际应用的二叉查找树必须引入自平衡算法。

二叉查找树的搜索

由于二叉查找树节点关键字的大小关系，搜索很自然地可以采用折半查找的策略。这里采用左子树优先的搜索策略，即先搜索左节点再搜索右节点。

node  *at(node *root, key_t key_argu) {
    node *ptr = root;
    while (ptr->key != key_argu) {
        if (ptr->left != NULL && key_argu < ptr->key ) {
            ptr = ptr->left;
        }
        else if (ptr->right != NULL &&  ptr->key < key_argu )           {
            ptr = ptr->right;
        }
        else {
            return NULL;
        }
    }
    return ptr;
}

二叉查找树添加节点

上文已提及二叉查找树具有不唯一性，生成的二叉查找树 与添加算法以及添加的顺序有关。这里采用左子树优先的策略添加节点，即在搜索添加位置时先搜索左子树。

由于目标节点不存在而导致左子树优先搜索失败的过程中所搜索路径最后一个节点即为新节点的父节点，比较新节点与父节点的键值可以知道添加到左还是右子节点。

定义node *append_node(node *root, key_t key_argu)函数实现向指定节点添加指定键值的子节点。当树为空树时只需对根节点赋值，无需建立新节点。

node *append(node *root, key_t key_argu) { // left is prior
    node *ptr = root, *nptr;
    //empty
    if (root->left == NULL && root->right==NULL) {
        root->key = key_argu;
        return root;
    }
    //non-empty
    //seek position
    while (ptr->key != key_argu) {
        if (key_argu < ptr->key ) {
            if (ptr->left) {
                ptr = ptr->left;
            }
            else {
                break;
            }
        }
        else if ( ptr->key < key_argu ) {
            if (ptr->right) {
                ptr = ptr->right;
            }
            else {
                break;
            }
        }
    }
    nptr=append_node(ptr,key_argu);
    return nptr;
}

二叉查找树删除节点

删除节点是这里要介绍的最的算法（没有之一），删除节点要保证删除后的数据结构仍然是二叉查找树。因为我们定义根节点作为二叉树的访问接口故不考虑删除根节点的问题。

删除节点要将其父节点指向目标节点的指针以及目标节点的左右子节点重新设定，并释放目标节点的内存空间。若目标节点为叶节点则直接删除 并将父节点指向目标节点的指针置为空指针即可；若目标节点只有一棵子树（只有左子树或只有右子树）则只需要用其子树替代目标节点的位置。

对于具有两棵子树的目标节点，要求将其删除后原左子树接在其原来的位置上；原右子树沿左子树最右侧分支寻找第一个空节点，并接在该空节点上。

定义rm函数作为删除节点操作的接口，定义工具函数rm0来处理目标节点具有两棵子树的情况。

node *rm0(node *root,node *ptr) {//no-root and with a full sub tree
    node *temp;
    temp = ptr;
    // replace ptr for ptr->left sub tree
    if (ptr == ptr->prior->left) {
        ptr->prior->left = ptr->left;
    }
     else if (ptr == ptr->prior->right) {
        ptr->prior->right = ptr->left;
    }
    //seek position for ptr->right sub tree
    ptr = ptr->left; //update ptr
    while (ptr->right) {
        ptr = ptr->right;
    }
    ptr->right = temp->right;
    free(temp);
    return root;
}

node *rm(node *root,key_t key_argu) { //cannot
    node *ptr;
    ptr = at(root,key_argu);
    if (ptr->left == NULL && ptr->right == NULL) {
        if (ptr == ptr->prior->left) {
            ptr->prior->left = NULL;
        }
        else {
            ptr->prior->right = NULL;
        }
        free(ptr);
    }
    else if (ptr->left != NULL && ptr->right == NULL) {
        if (ptr == ptr->prior->left) {
            ptr->prior->left = ptr->left;
        }
        else {
            ptr->prior->right = ptr->left;
        }
        free(ptr);
    }
    else if (ptr->left == NULL && ptr->right != NULL) {
        if (ptr == ptr->prior->left) {
            ptr->prior->left = ptr->right;
        }
        else {
            ptr->prior->right = ptr->right;
        }
        free(ptr);
    }
    else if (ptr->left ==! NULL && ptr->right != NULL) {
        rm0(root,ptr);
    }
    return root;
}

清空树

清空采用递归的方式进行，类似于中序遍历。

int clear(node *root) {
    node *ptr=root,*temp;
    if (ptr) {
        temp = ptr->right;
        clear(ptr->left);
        free(ptr);
        clear(temp);
    }
}

删除某一节点后会使其子树与根节点断开导致无法继续遍历，中序遍历的方式便于在清空后继续访问。程序流程与非递归中序遍历类似，在弹栈并更新当前节点后要将原当前节点删除，这需要一个临时指针存储原当前节点位置。

非递归实现：

int clear2(node *root) {
    node *ptr=root,*temp;
    node *stack[1024]={NULL};
    int top=0;//top of stack
    while (ptr || top>0) {
        if (ptr) {
            stack[top++]=ptr;//push
            ptr=ptr->left;
        }
        else {
            ptr=stack[--top];//ptr=stack top;pop;
            temp = ptr;
            ptr=ptr->right;
            free(temp);
        }
    }
    return num;
}
// 完整程序源码

#include <stdio.h>
#include <stdlib.h>
#define key_t char

typedef struct node{
    key_t key;
    struct node *prior;
    struct node *left;
    struct node *right;
}node;

int num=0;
inline int init_node(node *this){
    this->key='\0';
    this->prior=NULL;
    this->left=NULL;
    this->right=NULL;
    return 0;
}

inline node *append_node(node *prior_argu,key_t key_argu) {
    node *nptr;
    nptr=(node *)malloc(sizeof(node));
    init_node(nptr);
    nptr->prior = prior_argu;
    nptr->key = key_argu;
    if (key_argu < prior_argu->key) {
        prior_argu->left=nptr;
    }
    else if (key_argu > prior_argu->key) {
        prior_argu->right=nptr;
    }
    return nptr;
};

//using root ptr,and the root saves data too. using nullptr as the end.
inline int examp_tree(node *root) {
    root->key='m';
    //1st sub tree
    append_node(root,'f');
    append_node(root,'s');
    //2nd sub tree
    append_node(root->left,'d');
    append_node(root->left,'i');
    append_node(root->right,'p');
    append_node(root->right,'v');
    //3rd sub tree
    append_node(root->left->left,'b');
    append_node(root->left->left,'e');
    append_node(root->left->right,'g');
    append_node(root->left->right,'k');
    append_node(root->right->left,'n');
    append_node(root->right->left,'q');
    append_node(root->right->right,'t');
    append_node(root->right->right,'w');
    return 14;
}


int traver(node *root) { //unrecursion inorder traver
    node *ptr=root;
    node *stack[1024]={NULL};
    int top=0;//top of stack
    while (ptr || top>0) {
        if (ptr) {
            stack[top++]=ptr;//push
            ptr=ptr->left;
        }
        else {
            ptr=stack[--top];//ptr=stack top;pop;
            printf("%c ",ptr->key);//visit root
            num++;
            ptr=ptr->right;
        }
    }
    return num;
}

int depth(node *root) {
    int d1,d2;
    if (!root) {
        return 0;
    }
    d1=depth(root->left);
    d2=depth(root->right);
    return ((d1>d2)?d1:d2) + 1;
}

node *at(node *root, key_t key_argu) {
    node *ptr = root;
    while (ptr->key != key_argu) {
        if (ptr->left != NULL && key_argu < ptr->key ) {
            ptr = ptr->left;
        }
        else if (ptr->right != NULL &&  ptr->key < key_argu ) {
            ptr = ptr->right;
        }
        else {
            return NULL;
        }
    }
    return ptr;
}

node *append(node *root, key_t key_argu) { // left is prior
    node *ptr = root, *nptr;
    //empty
    if (root->left == NULL && root->right==NULL) {
        root->key = key_argu;
        return root;
    }
    //non-empty
    //seek position
    while (ptr->key != key_argu) {
        if (key_argu < ptr->key ) {
            if (ptr->left) {
                ptr = ptr->left;
            }
            else {
                break;
            }
        }
        else if ( ptr->key < key_argu ) {
            if (ptr->right) {
                ptr = ptr->right;
            }
            else {
                break;
            }
        }
    }
    nptr=append_node(ptr,key_argu);
    return nptr;
}

int rm0(node *root,node *ptr) {//no-root and with a full sub tree
    node *temp;
    temp = ptr;
    // replace ptr for ptr->left sub tree
    if (ptr == ptr->prior->left) {
        ptr->prior->left = ptr->left;
    }
     else if (ptr == ptr->prior->right) {
        ptr->prior->right = ptr->left;
    }
    //seek position for ptr->right sub tree
    ptr = ptr->left; //update ptr
    while (ptr->right) {
        ptr = ptr->right;
    }
    ptr->right = temp->right;
    free(temp);
    return 0;
}

node *rm(node *root,key_t key_argu) { //cannot
    node *ptr;
    ptr = at(root,key_argu);
    if (ptr->left == NULL && ptr->right == NULL) {
        if (ptr == ptr->prior->left) {
            ptr->prior->left = NULL;
        }
        else {
            ptr->prior->right = NULL;
        }
        free(ptr);
    }
    else if (ptr->left != NULL && ptr->right == NULL) {
        if (ptr == ptr->prior->left) {
            ptr->prior->left = ptr->left;
        }
        else {
            ptr->prior->right = ptr->left;
        }
        free(ptr);
    }
    else if (ptr->left == NULL && ptr->right != NULL) {
        if (ptr == ptr->prior->left) {
            ptr->prior->left = ptr->right;
        }
        else {
            ptr->prior->right = ptr->right;
        }
        free(ptr);
    }
    else if (ptr->left ==! NULL && ptr->right != NULL) {
        rm0(root,ptr);
    }
    return root;
}

int clear(node *root) {
    node *ptr=root,*temp;
    if (ptr) {
        temp = ptr->right;
        clear(ptr->left);
        free(ptr);
        clear(temp);
    }
}
int clear2(node *root) {
    node *ptr=root,*temp;
    node *stack[1024]={NULL};
    int top=0;//top of stack
    while (ptr || top>0) {
        if (ptr) {
            stack[top++]=ptr;//push
            ptr=ptr->left;
        }
        else {
            ptr=stack[--top];//ptr=stack top;pop;
            temp = ptr;
            ptr=ptr->right;
            free(temp);
        }
    }
    return num;
}

int main(void) {
    char ch;
    int n;
    node *temp,*root=(node *)malloc(sizeof(node));
    examp_tree(root);
    //display
    num=0;
    n=traver(root);
    printf("%d\n",n);
    return 0;
}
二叉排序树（二叉查找树、二叉搜索树）（图解+完整代码）
weixin_54186646的博客
04-25 10万+
图解二叉排序树（二叉查找树、二叉搜索树）的插入操作、查找操作、删除操作以及完整的代码实现
二叉查找树详解
m0_72674633的博客
06-08 1223
二叉查找树详解
二叉搜索数（二叉排序树、二叉查找树）-----详解
2301_80774875的博客
11-20 2692
二叉搜索树又称二叉排序树，它或者是一棵空树若它的左子树不为空，则左子树上所有节点的值都小于根节点的值若它的右子树不为空，则右子树上所有节点的值都大于根节点的值它的左右子树也分别为二叉搜索树在学习树型结构时，希望大家可以画图理解！！！！
数据结构：二叉查找树
梁辰兴的博客
09-17 1264
二叉查找树（Binary Search Tree，简称BST）是一种特殊的二叉树，其中每个节点都有一个可比较的键和一个关联的值，且对于每个节点，其左子树的所有键都小于节点的键，而右子树的所有键都大于节点的键。简介二叉查找树是一种自我平衡的二叉树，它的中序遍历会得到一个升序的序列。二叉查找树的每个节点都包含一个键和一个值，其中键用于保持树的排序，而值则可以是任何类型的数据。二叉查找树的主要操作包括插入、查找和删除。图示50/ \30 70/ \ / \
二叉查找树与平衡二叉树
热门推荐
金发只是水一下的博客
08-29 8万+
二叉查找树 　　二叉查找树，也称二叉搜索树，或二叉排序树。其定义也比较简单，要么是一颗空树，要么就是具有如下性质的二叉树： （1）若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2） 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3） 任意节点的左、右子树也分别为二叉查找树； （4） 没有键值相等的节点。 　　如上图所示，是不同形态...
一看就懂的二叉查找树和平衡二叉查找树
weixin_46272350的博客
10-04 1848
二叉查找树是一种特殊的二叉树，它可以组织动态数据集合，可以支持数据的快速插入，删除和查找操作。之前我们讨论过哈希表，他的，查找，插如和删除的时间复杂度是O(1)，既然哈希表这么高效，那么为什么还需要二叉查找树呢？ 二叉查找树的定义和操作 二叉查找树是二叉树中一种常用的一种类型。二叉查找树是为了实现快速查找产生的。不过，它不仅支持快速查找，还支持快速插入和删除。这主要归功于二叉查找树的一个特性，那就是树中任一节点，这个节点的左子树的值总是小于这个节点的值，这个节点右子树的值总是大于这个节点的值，.
二叉查找树/二叉平衡树/红黑树
m0_46977298的博客
07-16 2321
二叉查找树、二叉平衡树以及红黑树。
C/C++数据结构（十）—— 二叉查找树
Edison's 小宇宙
01-13 2万+
二叉查找树（Binary Search Tree），也称二叉排序树或二叉搜索树。
二叉查找树（BST）
小瑾的博客
05-19 1208
二叉查找树（BST）是一种特殊的二叉树，其每个节点的左子树值小于该节点，右子树值大于该节点。BST的基本操作包括查找、插入和删除，其中删除操作较为复杂，需根据节点子节点数量采取不同策略。BST的性能在平衡情况下为O(logn)，但在最坏情况下可能退化为O(n)。BST的扩展应用包括AVL树、红黑树、伸展树和Treap等，它们通过不同机制保持树的平衡。
二叉查找树 减治法——C++代码
05-24
二叉查找树（Binary Search Tree，BST）是一种特殊的二叉树数据结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉查找树中，对于任意节点，其左子树中的...
二叉查找树python二叉查找树源码
11-22
二叉查找树（Binary Search Tree，BST），也称为二叉排序树，是一种特殊的二叉树数据结构。它的每个节点都包含一个键（key）、一个关联的值、一个指向左子节点的指针和一个指向右子节点的指针。在二叉查找树中，对于...
最优二叉查找树 动态规划法.cpp.rar
10-14
最优二叉查找树（Optimal Binary Search Tree, OBST）是一种高效的检索数据结构，它根据键值分布的不同，自适应地调整树的形态以达到最小化查找时间的目的。在计算机科学中，动态规划（Dynamic Programming, DP）是...
JS实现二叉查找树的建立以及一些遍历方法实现
10-20
在计算机科学中，二叉查找树（BST）是一种特殊的二叉树结构，它满足所有节点的左子树都小于该节点，所有节点的右子树都大于该节点。这种特性使得二叉查找树在查找、插入和删除元素时可以提供很高的效率。本文将详细...
二叉树的前中后序遍历(迭代法)
mrjieke6的博客
09-07 1287
本文系统介绍了二叉树前序、中序和后序遍历的迭代实现方法。前序遍历采用栈结构，按;根→右→左 ;顺序入栈；中序遍历先全部左子树入栈再访问节点；后序遍历则通过修改前序遍历顺序为"根→右→左 ;后反转结果。三种遍历时间复杂度均为O(n)，空间复杂度最坏O(n)。与递归实现相比，迭代方法避免了栈溢出风险，处理大型树更稳定。每种遍历方式都配有详细代码解析、执行示例和复杂度分析，并讨论了实际应用场景，为掌握树结构操作提供了系统指导。
每日算法刷题Day67:9.9:leetcode bfs10道题，用时2h30min
2301_80044595的博客
09-09 567
2.与[[十.图论算法-基础遍历#3. 1162. 地图分析(中等,学习)]]一模一样，找每个1到各自最近的0的最短距离，即多源最短路径距离，所以将所有0入队列，向四周扩散，告诉1已经扩散的层数，即距离。所以要反过来，将所有满足条件的点当做多个源点，向外扩散，从而告诉待求点当前扩散的层数，即最短距离。，是Dijkstra算法，但因为边权只有0和1，所以用0-1BFS来优化Dijkstra，双端队列队首入0，队尾入1，保证每次队首都是边权(代价)最小的。的视频包含所有你好友的好友观看过的视频，以此类推。
【无标题】
最新发布
Leeyy
09-10 622
过拟合是指模型在训练集上表现很好，但在测试集上表现较差的现象。
【牛客刷题-剑指Offer】BM18 二维数组中的查找：一题四解，从暴力到最优
字节卷动
09-06 187
方法时间复杂度空间复杂度优点缺点适用场景暴力遍历On×mOn×mO1O(1)O1简单直接，易实现效率低，不适合大数据量小规模数据二分查找Omlog⁡nOmlognO1O(1)O1利用行有序，效率较高未利用列有序特性行数较少时Z字形查找OnmO(n + m)OnmO1O(1)O1最优解，利用行列有序无各种规模数据递归分治平均优于OnmO(nm)OnmOlog⁡nmOlognm。
详解二叉查找树BST及其遍历算法
二叉查找树（Binary Search Tree，简称BST）是一种重要的数据结构，它支持多种动态集合操作，如查找、插入、删除等。在计算机科学与信息处理领域中，BST是一种广泛应用于各种系统和应用的高效数据结构，特别是在需要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值