详解二叉查找树算法的实现

最新推荐文章于 2022-10-08 10:24:55 发布
最新推荐文章于 2022-10-08 10:24:55 发布
阅读量1.7k 收藏 2
点赞数 1
分类专栏： 数据结构与算法

详解二叉查找树算法的实现

http://blog.csdn.net/npy_lp/article/details/7426431


标签： 算法inserttreedeletenullsearch
2012-04-06 13:32  22486人阅读  评论(14)  收藏  举报
  分类：
 

版权声明：本文为博主原创文章，未经博主允许不得转载。

    参考文献： 《数据结构（C语言版）》  严蔚敏 吴伟民 编著

 

    开发平台：Ubuntu11.04

    编译器：gcc version4.5.2 (Ubuntu/Linaro 4.5.2-8ubuntu4)

 

    树（Tree）是n（n≥0）个结点的有限集。在任意一棵非空树中：（1）有且仅有一个特定的被称为根（Root）的结点；（2）当n>1时，其余结点可分为m（m>0）个互不相交的有限集T1，T2，…，Tm，其中每一个集合本身又是一棵树，并且称为根的子树（SubTree）。

    结点拥有的子树数称为结点的度（Degree）。度为0的结点称为叶子（Leaf）或终端结点。度不为0的结点称为非终端结点或分支结点。

    树的度是树内各结点的度的最大值。

    结点的子树的根称为该结点的孩子（Child），相应地，该结点称为孩子的双亲（Parent）。

    结点的层次（Level）是从根结点开始计算起，根为第一层，根的孩子为第二层，依次类推。树中结点的最大层次称为树的深度（Depth）或高度。

    如果将树中结点的各子树看成从左至右是有次序的（即不能互换），则称该树为有序树，否则称为无序树。

    1、二叉树

    二叉树（Binary Tree）的特点是每个结点至多具有两棵子树（即在二叉树中不存在度大于2的结点），并且子树之间有左右之分。

    二叉树的性质：

    （1）、在二叉树的第i层上至多有2i-1个结点（i≥1）。

    （2）、深度为k的二叉树至多有2k-1个结点（k≥1）。

    （3）、对任何一棵二叉树，如果其终端结点数为n0，度为2的结点数为n2，则n0=n2+1。

    一棵深度为k且有2k-1个结点的二叉树称为满二叉树。

    可以对满二叉树的结点进行连续编号，约定编号从根结点起，自上而下，自左至右，则由此可引出完全二叉树的定义。深度为k且有n个结点的二叉树，当且仅当其每一个结点都与深度为k的满二叉树中编号从1到n的结点一一对应时，称之为完全二叉树。

 

    （4）、具有n个结点的完全二叉树的深度为不大于log2n的最大整数加1。

    （5）、如果对一棵有n个结点的完全二叉树的结点按层序编号（从第1层到最后一层，每层从左到右），则对任一结点i（1≤i≤n）,有

    a、如果i=1,则结点i是二叉树的根，无双亲；如果i>1，则其双亲是结点x（其中x是不大于i/2的最大整数）。

    b、如果2i>n，则结点i无左孩子（结点i为叶子结点）；否则其左孩子是结点2i。

    c、如果2i+1>n，则结点i无右孩子；否则其右孩子是结点2i+1。

    二叉树的链式存储：

    链式二叉树中的每个结点至少需要包含三个域，数据域和左、右指针域。

 

    二叉树的遍历：

    假如以L、D、R分别表示遍历左子树、访问根结点和遍历右子树，则可有DLR、DRL、LRD、LDR、RLD、RDL这六种遍历二叉树的方案。若限定先左后右，则只有三种方案，分别称之为先（根）序遍历、中（根）序遍历和后（根）序遍历，它们以访问根结点的次序来区分。

    2、二叉查找树

    二叉查找树（BinarySearch Tree，也叫二叉搜索树，或称二叉排序树Binary Sort Tree）或者是一棵空树，或者是具有下列性质的二叉树：

    （1）、若它的左子树不为空，则左子树上所有结点的值均小于它的根结点的值；

    （2）、若它的右子树不为空，则右子树上所有结点的值均大于它的根结点的值；

    （3）、它的左、右子树也分别为二叉查找树。

    3、二叉查找树的基本运算 

[cpp]  view plain  copy
  1. /* bst - binary search/sort tree  
  2.  * by Richard Tang <tanglinux@gmail.com>  
  3.  */  
  4. #include <stdio.h>  
  5. #include <stdlib.h>  
  6.   
  7. typedef int data_type;  
  8.   
  9. typedef struct bst_node {  
  10.     data_type data;  
  11.     struct bst_node *lchild, *rchild;  
  12. }bst_t, *bst_p;  

    （1）、插入

    在二叉查找树中插入新结点，要保证插入新结点后仍能满足二叉查找树的性质。例子中的插入过程如下：

    a、若二叉查找树root为空，则使新结点为根；

    b、若二叉查找树root不为空，则通过search_bst_for_insert函数寻找插入点并返回它的地址（若新结点中的关键字已经存在，则返回空指针）；

    c、若新结点的关键字小于插入点的关键字，则将新结点插入到插入点的左子树中，大于则插入到插入点的右子树中。 

[cpp]  view plain  copy
  1. static bst_p search_bst_for_insert(bst_p *root, data_type key)  
  2. {  
  3.     bst_p s, p = *root;  
  4.   
  5.     while (p) {  
  6.     s = p;  
  7.   
  8.     if (p->data == key)  
  9.         return NULL;  
  10.   
  11.     p = (key < p->data) ? p->lchild : p->rchild;  
  12.     }  
  13.   
  14.     return s;  
  15. }  
  16.   
  17. void insert_bst_node(bst_p *root, data_type data)  
  18. {  
  19.     bst_p s, p;  
  20.   
  21.     s = malloc(sizeof(struct bst_node));  
  22.     if (!s)  
  23.     perror("Allocate dynamic memory");  
  24.   
  25.     s -> data = data;  
  26.     s -> lchild = s -> rchild = NULL;  
  27.   
  28.     if (*root == NULL)  
  29.     *root = s;  
  30.     else {  
  31.     p = search_bst_for_insert(root, data);  
  32.     if (p == NULL) {  
  33.         fprintf(stderr, "The %d already exists.\n", data);  
  34.         free(s);  
  35.         return;  
  36.     }  
  37.   
  38.     if (data < p->data)  
  39.         p->lchild = s;  
  40.     else  
  41.         p->rchild = s;  
  42.     }  
  43. }  

    （2）、遍历 

[cpp]  view plain  copy
  1. static int print(data_type data)  
  2. {  
  3.     printf("%d ", data);  
  4.   
  5.     return 1;  
  6. }  
  7.   
  8. int pre_order_traverse(bst_p root, int (*visit)(data_type data))   
  9. {  
  10.     if (root) {  
  11.     if (visit(root->data))  
  12.         if (pre_order_traverse(root->lchild, visit))  
  13.             if (pre_order_traverse(root->rchild, visit))  
  14.                 return 1;  
  15.     return 0;  
  16.     }  
  17.     else  
  18.     return 1;  
  19. }  
  20.   
  21. int post_order_traverse(bst_p root, int (*visit)(data_type data))  
  22. {  
  23.     if (root) {  
  24.     if (post_order_traverse(root->lchild, visit))  
  25.         if (visit(root->data))  
  26.         if (post_order_traverse(root->rchild, visit))  
  27.             return 1;  
  28.     return 0;  
  29.     }  
  30.     else  
  31.     return 1;  
  32. }  

    中序遍历二叉查找树可得到一个关键字的有序序列。

    （3）、删除

    删除某个结点后依然要保持二叉查找树的特性。例子中的删除过程如下：

    a、若删除点是叶子结点，则设置其双亲结点的指针为空。

    b、若删除点只有左子树，或只有右子树，则设置其双亲结点的指针指向左子树或右子树。

    c、若删除点的左右子树均不为空，则：

    1）、查询删除点的右子树的左子树是否为空，若为空，则把删除点的左子树设为删除点的右子树的左子树。

 

    2）、若不为空，则继续查询左子树，直到找到最底层的左子树为止。

 

[cpp]  view plain  copy
  1. void delete_bst_node(bst_p *root, data_type data)  
  2. {  
  3.     bst_p p = *root, parent, s;  
  4.   
  5.     if (!p) {  
  6.     fprintf(stderr, "Not found %d.\n", data);  
  7.     return;  
  8.     }  
  9.   
  10.     if (p->data == data) {  
  11.     /* It's a leaf node */  
  12.     if (!p->rchild && !p->lchild) {  
  13.         *root = NULL;  
  14.         free(p);  
  15.     }  
  16.     /* the right child is NULL */  
  17.     else if (!p->rchild) {  
  18.         *root = p->lchild;  
  19.         free(p);  
  20.     }  
  21.     /* the left child is NULL */  
  22.     else if (!p->lchild) {  
  23.         *root = p->rchild;  
  24.         free(p);  
  25.     }  
  26.     /* the node has both children */  
  27.     else {  
  28.         s = p->rchild;  
  29.         /* the s without left child */  
  30.         if (!s->lchild)  
  31.         s->lchild = p->lchild;  
  32.         /* the s have left child */  
  33.         else {  
  34.         /* find the smallest node in the left subtree of s */  
  35.         while (s->lchild) {  
  36.             /* record the parent node of s */  
  37.             parent = s;  
  38.             s = s->lchild;  
  39.         }  
  40.         parent->lchild = s->rchild;  
  41.         s->lchild = p->lchild;  
  42.         s->rchild = p->rchild;  
  43.         }  
  44.         *root = s;  
  45.         free(p);  
  46.     }  
  47.     }   
  48.     else if (data > p->data) {  
  49.     delete_bst_node(&(p->rchild), data);  
  50.     }   
  51.     else if (data < p->data) {  
  52.     delete_bst_node(&(p->lchild), data);  
  53.     }  
  54. }  

    4、二叉查找树的查找分析

    同样的关键字，以不同的插入顺序，会产生不同形态的二叉查找树。 

[cpp]  view plain  copy
  1. int main(int argc, char *argv[])  
  2. {  
  3.     int i, num;  
  4.     bst_p root = NULL;  
  5.   
  6.     if (argc < 2) {  
  7.     fprintf(stderr, "Usage: %s num\n", argv[0]);  
  8.     exit(-1);  
  9.     }  
  10.   
  11.     num = atoi(argv[1]);  
  12.     data_type arr[num];  
  13.     printf("Please enter %d integers:\n", num);  
  14.     for (i = 0; i < num; i++) {  
  15.     scanf("%d", &arr[i]);  
  16.     insert_bst_node(&root, arr[i]);  
  17.     }  
  18.   
  19.     printf("\npre order traverse: ");  
  20.     pre_order_traverse(root, print);  
  21.     printf("\npost order traverse: ");  
  22.     post_order_traverse(root, print);  
  23.     printf("\n");  
  24.   
  25.     delete_bst_node(&root, 45);  
  26.   
  27.     printf("\npre order traverse: ");  
  28.     pre_order_traverse(root, print);  
  29.     printf("\npost order traverse: ");  
  30.     post_order_traverse(root, print);  
  31.     printf("\n");  
  32.       
  33.     return 0;  
  34. }  

    运行两次，以不同的顺序输入相同的六个关键字：

     

    根据前序遍历的结果可得到两次运行所产生的二叉查找树的形态并不相同，如下图：

 

顶
4
踩
0
我的同类文章
猜你在找
《C语言/C++学习指南》加密解密篇（安全相关算法）
C语言系列之 快速排序与全排列算法
Ceph—分布式存储系统的另一个选择
4.7.存储类&作用域&生命周期&链接属性-C语言高级专题第7部分
Cocos2d-x 3.x高级视频教程：ObjC、Swift、C++、Java交互
查看评论
8楼  云峦雾绕 2016-01-26 09:59发表 [回复]
int (*visit)(data_type data)
可能是我太鶸了这种定义形参的方法没有用过，可以给点资料看看么。。。这样的形参定义是什么意思。。。
Re:  tanglinux 2016-02-23 15:56发表 [回复]
回复bochuan007：就是一个指针，函数指针。
7楼  jielidu 2016-01-22 15:51发表 [回复]
http://www.algolist.net/Data_structures/Binary_search_tree/Removal

这个里面讲解删除部分，挺好理解的。
6楼  倔强的攻城狮 2015-11-05 16:11发表 [回复]
楼主的节点操作图是用什么工具画的呀？
Re:  tanglinux 2015-11-06 09:13发表 [回复]
回复Quyuan2009：开始菜单“附件”里的“画图”工具。
Re:  倔强的攻城狮 2015-11-07 22:33发表 [回复]
回复npy_lp：厉害，完全专业画工的节奏
5楼  dijkstral 2015-07-11 09:41发表 [回复]
博主你的删除节点的方法比较精妙，但是和算法导论中的不一样啊。
4楼  baidu_28619017 2015-06-01 16:44发表 [回复]
经过调试，在我依次插入 1 2 3后，用pre_dst_traverse函数打印时候，出现仅打印一个数的错误,深度没有错
这里我经思考理解，LZ的思路是，可以实现自己编写的对数据的处理程序，在遍历时候，若不符合某些条件即刻弹出遍历
修改如下:
int pre_dst_traverse(bst_p s,void(*fun)(type_data data){
if(!s) return 1; //仅仅弹出当次栈，不影响遍历继续
if(fun(s->data)){
if(pre_dst_traverse(s->lchild,fun){
if(pre_dst_traverse(s->rchild,fun){
return 1; //依旧不影响
}
}
return 0; 
}
else return 0; //重点在这，当fun返回0后，往之前的栈返回0,接着按照传递性,立即弹出所有栈，终止递归
}
3楼  h1031565585 2015-05-11 21:46发表 [回复]
好复杂啊，看不懂
2楼  TeddyBear777 2015-05-09 05:30发表 [回复]
int post_order_traverse(bst_p root, int (*visit)(data_type data)) 

写错了吧，你实现的是in_order_traverse.
Re:  tanglinux 2015-05-17 17:30发表 [回复]
回复a714833738：你说的没错，是中序遍历。
1楼  sicoso 2014-03-08 22:41发表 [回复]
b、若删除点只有左子树，或只有右子树，则设置其双亲结点的指针指向左子树或右子树。

这里没看懂，请问：若被删除节点只有右子树，他的双亲节点同时有左子树（被删除节点）和右子树，那怎么设置其双亲节点指向右子树？

我是菜鸟，，，所以可能问的很笨。。
Re:  tanglinux 2014-03-08 23:18发表 [回复]
回复sicoso：双亲节点的右子树保持不变。
这句话更准确地描述为“b、若删除点只有左子树，或只有右子树，则让其双亲结点原指向该删除点的指针指向这个删除点的左子树或右子树。”。
Re:  sicoso 2014-03-09 09:40发表 [回复]
回复npy_lp：噢，谢谢，刚刚理解错了。
发表评论
  • 用 户 名：
  • zkl99999


叉查找树--插入、删除、查找

　　二叉查找树是满足以下条件的二叉树：1.左子树上的所有节点值均小于根节点值，2右子树上的所有节点值均不小于根节点值，3，左右子树也满足上述两个条件。

　　二叉查找树的插入过程如下：1.若当前的二叉查找树为空，则插入的元素为根节点，2.若插入的元素值小于根节点值，则将元素插入到左子树中，3.若插入的元素值不小于根节点值，则将元素插入到右子树中。

　　二叉查找树的删除，分三种情况进行处理：

　　1.p为叶子节点，直接删除该节点，再修改其父节点的指针（注意分是根节点和不是根节点），如图a。

　　2.p为单支节点（即只有左子树或右子树）。让p的子树与p的父亲节点相连，删除p即可；（注意分是根节点和不是根节点）；如图b。

　　3.p的左子树和右子树均不空。找到p的后继y，因为y一定没有左子树，所以可以删除y，并让y的父亲节点成为y的右子树的父亲节点，并用y的值代替p的值；或者方法二是找到p的前驱x，x一定没有右子树，所以可以删除x，并让x的父亲节点成为y的左子树的父亲节点。如图c。

 

 

  

插入节点的代码：

复制代码 
struct node
{
    int val;
    pnode lchild;
    pnode rchild;
};

pnode BT = NULL;


//递归方法插入节点 
pnode insert(pnode root, int x)
{
    pnode p = (pnode)malloc(LEN);
    p->val = x;
    p->lchild = NULL;
    p->rchild = NULL;
    if(root == NULL){
        root = p;    
    }    
    else if(x < root->val){
        root->lchild = insert(root->lchild, x);    
    }
    else{
        root->rchild = insert(root->rchild, x);    
    }
    return root;
}

//非递归方法插入节点 
void insert_BST(pnode q, int x)
{
    pnode p = (pnode)malloc(LEN);
    p->val = x;
    p->lchild = NULL;
    p->rchild = NULL;
    if(q == NULL){
        BT = p;
        return ;    
    }        
    while(q->lchild != p && q->rchild != p){
        if(x < q->val){
            if(q->lchild){
                q = q->lchild;    
            }    
            else{
                q->lchild = p;
            }        
        }    
        else{
            if(q->rchild){
                q = q->rchild;    
            }    
            else{
                q->rchild = p;    
            }
        }
    }
    return;
}
复制代码

查找节点的代码：

复制代码 
pnode search_BST(pnode p, int x)
{
    bool solve = false;
    while(p && !solve){
        if(x == p->val){
            solve = true;    
        }    
        else if(x < p->val){
            p = p->lchild;    
        }
        else{
            p = p->rchild;    
        }
    }
    if(p == NULL){
        cout << "没有找到" << x << endl;    
    } 
    return p;
}
复制代码

删除节点的代码

复制代码 
bool delete_BST(pnode p, int x) //返回一个标志，表示是否找到被删元素 
{
    bool find = false;
    pnode q;
    p = BT;
    while(p && !find){  //寻找被删元素 
        if(x == p->val){  //找到被删元素 
            find = true;    
        }    
        else if(x < p->val){ //沿左子树找 
            q = p;
            p = p->lchild;    
        }
        else{   //沿右子树找 
            q = p;
            p = p->rchild;    
        }
    }
    if(p == NULL){   //没找到 
        cout << "没有找到" << x << endl;    
    }
    
    if(p->lchild == NULL && p->rchild == NULL){  //p为叶子节点 
        if(p == BT){  //p为根节点 
            BT = NULL;    
        }
        else if(q->lchild == p){   
            q->lchild = NULL;
        }        
        else{
            q->rchild = NULL;    
        }
        free(p);  //释放节点p 
    }
    else if(p->lchild == NULL || p->rchild == NULL){ //p为单支子树 
        if(p == BT){  //p为根节点 
            if(p->lchild == NULL){
                BT = p->rchild;    
            }    
            else{
                BT = p->lchild;    
            }
        }    
        else{
            if(q->lchild == p && p->lchild){ //p是q的左子树且p有左子树 
                q->lchild = p->lchild;    //将p的左子树链接到q的左指针上 
            }    
            else if(q->lchild == p && p->rchild){
                q->lchild = p->rchild;    
            }
            else if(q->rchild == p && p->lchild){
                q->rchild = p->lchild;    
            }
            else{
                q->rchild = p->rchild;
            }
        }
        free(p);
    }
    else{ //p的左右子树均不为空 
        pnode t = p;
        pnode s = p->lchild;  //从p的左子节点开始 
        while(s->rchild){  //找到p的前驱，即p左子树中值最大的节点 
            t = s;   
            s = s->rchild;    
        }
        p->val = s->val;   //把节点s的值赋给p 
        if(t == p){
            p->lchild = s->lchild;    
        }    
        else{
            t->rchild = s->lchild;    
        }
        free(s); 
    }
    return find;
}
复制代码

 

标签:  数据结构
2
0
(请您对文章做出评价)
« 上一篇： 最小生成树（prime算法、kruskal算法） 和 最短路径算法（floyd、dijkstra）
» 下一篇： 二分查找小技巧
posted @  2012-03-27 18:00  爱也玲珑 阅读( 13488) 评论( 5)  编辑  收藏

  
#1楼   2013-08-28 15:20 |  北天帝君   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
pnode insert(pnode root,  int  x)
{
     <b>pnode p = (pnode) malloc (LEN);
     p->val = x;
     p->lchild = NULL;
     p->rchild = NULL;</b>
     if (root == NULL){
         root = p;   
     }   
     else  if (x < root->val){
         root->lchild = insert(root->lchild, x);   
     }
     else {
         root->rchild = insert(root->rchild, x);   
     }
     return  root;
}



加粗的代码部分似乎应该放在
if（root == NULL）{

}
中
支持(0) 反对(0)
  
#2楼   2014-04-11 16:12 |  ┌LiHoo┐   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
typedef  struct  node
{
     int  val;
     pnode lchild;
     pnode rchild;
}node,*pnode;
 
pnode insert(pnode & root,  int  x)
{
     
     if (root == NULL){
           pnode p = (pnode) malloc (LEN);
           p->val = x;
           p->lchild = NULL;
           p->rchild = NULL;
           root = p;   
     }   
     else  if (x < root->val){
         root->lchild = insert(root->lchild, x);   
     }
     else {
         root->rchild = insert(root->rchild, x);   
     }
     return  root;
}


原本的递归插入时，root = p;并没有成功更新到，需要双指针或则引用指针才行
支持(0) 反对(0)
  
#3楼   2014-08-12 15:33 |  洪荒大侠   
演示节点删除的例子说的感觉有点儿不清楚，究竟是删除哪个节点？
支持(0) 反对(0)
  
#4楼   2014-08-12 15:35 |  洪荒大侠   
感觉删除节点的程序有些模糊
支持(0) 反对(0)
  
#5楼   2015-11-20 22:10 |  sjtuzcc   
pnode是什么意思？怎么直接用它来创建指向node的指针？


learn deep learning
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉搜索树
m0_59278204的博客
10-29 43
二叉搜索树
算法数据结构——二叉搜索树（Binary Search Tree）精讲及python实现
白话机器学习
06-05 841
二叉搜索树（Binary Search Tree）：也叫做二叉查找树、有序二叉树或者排序二叉树。是指一棵空树或者具有下列性质的二叉树：如果任意节点的左子树不为空，则左子树上所有节点的值均小于它的根节点的值。如果任意节点的右子树不为空，则右子树上所有节点的值均大于它的根节点的值。任意节点的左子树、右子树均为二叉搜索树。如图所示，这 $3$ 棵树都是二叉搜索树。二叉树具有一个特性，即：$左子树的节点值 < 根节点值 < 右子树的节点值$。
二叉搜索（查找）树的查找/插入/删除以及二叉树搜索树的建立等基本操作的详细介绍
qq_45768060的博客
05-18 2112
二叉搜索树（BST，Binary Search Tree）， 也称二叉排序树或二叉查找树 定义 二叉搜索树：一棵二叉树，可以为空；如果不为空，满足以下性质： 非空左子树的所有结点的值小于其根结点的值。 非空右子树的所有结点的值大于其根结点的值。 左、右子树都是二叉搜索树。 ...
数据结构——二叉搜索树(干货满满)
weixin_57023347的博客
06-15 3728
文章目录一.定义二.基本操作1.查找查找某一结点查找树的最大值：查找树的最小值：2.插入3.删除三.性质 一.定义 二叉搜索树是一种队排序和查找都很有用的特殊二叉树。又称为二叉排序树和二叉查找树。其定义如下： 1.二叉查找树为空树 2.非空左子树所有结点的值小于根节点的值 3.非空右子树所有结点的值大于根节点的值 4.左右子树都是二叉搜索树 事例：如图就是一颗二叉搜索树，根节点值为5，其左子树值均小于5，右子树的值均大于5，并且在左子树，右子树中均符合这种情况。 二.基本操作 树信息： typedef
数据结构(C++)： 二叉搜索树 实现篇
weixin_57761086的博客
10-08 1505
讲解二叉搜索树的各种操作，在查找，插入，删除操作的讲解中，配置了大量插图，可以帮助读者清晰的了解每个过程。在二叉搜索树的实现中，也在代码中添加大量注释，帮助读者理解代码。
C语言 二叉查找树性质详解及实例代码
01-21
二叉查找树性质 1、二叉树 每个树的节点最多有两个子节点的树叫做二叉树。 2、二叉查找树 一颗二叉查找树是按照二叉树的结构来组织的，并且满足一下性质： 一个节点所有左子树上的节点不大于盖节点，所有右子树的...
JS中的算法与数据结构之二叉查找树（Binary Sort Tree）实例详解
10-16
在JavaScript中，二叉查找树可以通过定义Node类和BST类来实现。Node类包含数据、左右子节点的引用以及显示数据的方法。BST类包含根节点属性以及插入、遍历、查找、删除等方法。例如，插入操作在BST类中通过递归实现...
转载 查找算法 二叉排序树.doc
05-08
二叉排序树，也被称为二叉查找树，是一种特殊类型的二叉树，其设计目的是为了高效地执行查找、插入和删除等操作。它满足以下三个特性： 1. 如果二叉排序树为空，那么它就是空树。 2. 如果树不为空，那么左子树中...
Linux内核中红黑树算法的实现详解
09-15
红黑树是计算机科学中...总结来说，Linux内核中的红黑树实现通过精心设计的数据结构和操作宏，实现了高效、自平衡的二叉查找树。这种实现方式保证了内核在处理大量数据时的高效率，是操作系统内核设计的关键组成部分。
二分查找算法详解与实现.zip
最新发布
06-17
二分查找算法广泛应用于各种数据结构（如堆、平衡二叉搜索树）和问题求解中，例如在大型有序数据集上进行快速查找、排序算法的辅助工具（如快速排序中的划分操作）、以及几何问题（如求最近点对）等。 通过阅读“二...
详解常用查找数据结构及算法（Python实现）
12-24
查找（Searching）就是根据给定的某个值，在查找表中确定一个其关键字等于给定值的数据元素（或记录）。 查找表（Search Table）：由同一类型的数据元素（或记录）构成的集合 关键字（Key）：数据元素中某个数据项...
PHP实现的折半查找算法示例
10-18
此外，如果数据量非常大，可以考虑使用二分查找的变种，如跳表、平衡二叉查找树等数据结构，以适应更大规模的数据处理。 **总结** 折半查找是一种高效的搜索算法，尤其适合于有序数据集。通过PHP的递归或非递归...
c代码-平衡二叉查找树 --AVL树
07-16
在IT领域，平衡二叉查找树（Balanced Binary Search Tree，简称BBST）是一类重要的数据结构，它们在保持二叉查找树特性的同时，通过特定的平衡策略确保了高效的查找、插入和删除操作。其中，AVL树是最早被提出的自...
常用排序查找算法详解
03-05
"红黑树 [RBT]"和"二叉搜索树（BST）"是两种常见的自平衡二叉查找树。红黑树确保了任何节点到其每个叶子节点的所有路径都包含相同数量的黑色节点，从而保持了相对平衡，提高了查找效率。二叉搜索树则具有左子节点...
搜索二叉树的递归算法
weixin_44077170的博客
11-06 560
#include<iostream> using namespace std; typedef struct student { int data; student *left; student *right; }*Btree,btree; void init_tr...
二叉搜索树的实现
Linging_24的博客
10-31 239
二叉搜索树(BST) 二叉搜索树它是二叉树的一种类别，其节点按特定顺序排列。这也称为有序二叉树。 在二叉搜索树中，左子树中所有节点的值小于根的值。 类似地，右子树中所有节点的值大于或等于根的值。 此规则将递归地应用于根的所有左子树和右子树。 前序遍历：30，15，7，22，17，27，60，45，75 中序遍历： 7，15，17，22，27，30，45，60，75 后序遍历：7，17，27，22，15，45，75，60，30 二叉查找树的实现： API设计： 1.节点类： 2.二叉搜索树类： //
二叉查找树查找指定排名元素的算法
J.的学习室
07-21 2959
问题如下：1.查找在二叉查找树中按大小排名为k的节点（如果元素x排名为k，则有k个元素排在x的前面，排名以0为起点），以升序排序                      2.给出指定键值，返回其在二叉查找树中的排名，升序排序 第1个问题分析：1.任意节点的左子树中的所有节点一定排在自身前面      2.如果左子树中节点不足，比如查找排名为6的节点，但左子树中只有3个节点，则在右子
数据结构——二叉搜索树之节点删除
真一居士的博客
04-21 878
/** * 二叉搜索树的删除一般分为三种情况； * 1. 要删除的节点本身是叶子结点 -> 直接删除 * 2. 要删除的节点本身只有一个孩子节点 -> 用孩子节点替换他 * 3. 要删除的节点本身有两个孩子节点 -> 找到该节点A 的后继节点(比该节点大的最小节点，也就是右子树的最左叶子结点)B 然后用B替换A 最后再右子树中删除B(又可以...
二叉查找树与红黑树算法详解
"二叉查找树的查找算法-红黑树算法" 二叉查找树，也称为二叉搜索树，是一种自平衡的二叉树数据结构，其特点是每个节点的左子树只包含键小于当前节点键的节点，而右子树则包含键大于当前节点键的节点。这种特性使得...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值