C语言—二叉查找树经典实例

已于 2023-02-07 15:11:06 修改
阅读量683 收藏 5
点赞数 1
分类专栏： C语言 文章标签： c语言 树结构
于 2021-08-12 20:49:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45586218/article/details/119653061
版权

一、项目结构图

codeblocks项目工作区视图

二、二叉查找树介绍：

（一）二叉查找树ADT

类型名： 二叉查找树
类型属性： 二叉树要么是空节点的集合（空树），要么是有一个根节点的节点集合
每个节点都有两个子树，叫做左子树和右子树
每个子树本身也是一个二叉树，也有可能是空树
二叉查找树是一个有序的二叉树，每个节点包含一个项，
左子树的所有项都在根节点的前面，右子树的所有项都在根节点项的后面
类型操作：
初始化树为空
确定树是否为空
确定树是否已满
确定树中的项数
在树中添加一个项
在树中删除一个项
在树中查找一个项
在树中访问一个项
清空树

（二）二叉查找树接口：

原则上，可以用多种方法实现二叉查找树，甚至可以通过操控数组下标来实现，但是，实现二叉查找树最直接的方法是通过指针动态分配链式节点。常用的定义形式如下：
typedef SOMETHING Item;

typedef struct trnode
{
Item item;
struct trnode * left;
struct trnode * right;
} Trnode;

typedef struct tree
{
Trnode * root;
int size;
} Tree;

每个节点包含一个项，一个指向左子节点的指针和一个指向右子节点的指针。可以直接把Tree定义为指向Trnode的指针类型，因为只需要知道根节点的位置就可以访问整个树，然而使用有成员大小的结构能方便的记录树的大小。

三、真枪实战

（一）题目要求（需求）

我们要开发一个维护Nerfville宠物俱乐部的花名册，每一项都包含宠物名和宠物的种类。把数的大小限制为10，较小的树便于在树中已满时测试程序的行为是否正确，当然你也可以把MAXITEMS设置为更大的值。

（二）代码如下（实现）：

一、tree.h

/*tree.h -- 二叉查找树 */
/* 该定义假设不允许有重复的项*/
#ifndef TREE_H_INCLUDED
#define TREE_H_INCLUDED
#include<stdbool.h>

/*根据具体情况定义 Item*/
#define SLEN 20
typedef struct item
{
    char petname[SLEN];
    char petkind[SLEN];
} Item;

#define MAXITEMS 10

typedef struct trnode
{
    Item item;
    struct trnode * left; //指向左分支的指针
    struct trnode * right; //指向右分支的指针
} Trnode;

typedef struct tree{
    Trnode * root;
    int size;
} Tree;

/* 函数原型 */

/*操作：   把树初始化为空*/
/*前提条件  ptree指向一个树*/
/*后置条件  树被初始化为空*/
void InitiallizeTree(Tree * ptree);


/*操作    确定树是否为空*/
/*前提条件  ptree指向一个已初始化的树 */
/*后置条件  如果树为空，该函数返回true，否则返回false*/
bool TreeIsEmpty(const Tree * ptree);


/*操作    确定树是否已满*/
/*前提条件  ptree指向一个已初始化的树 */
/*后置条件  如果树已满，该函数返回true，否则返回false*/
bool TreeIsFull(const Tree * ptree);


/*操作    确定树的项数*/
/*前提条件  ptree指向一个已初始化的树 */
/*后置条件  返回树的项数*/
int TreeItemCount(const Tree * ptree);


/*操作    在树中添加一个项*/
/*前提条件  pi是待添加的地址
            ptree指向一个已初始化的树 */
/*后置条件  如果可以添加，将在书中添加一个项，并返回true；否则返回false*/
bool AddItem(const Item * pi,Tree * ptree);


/*操作    在树中查找一个项*/
/*前提条件  pi指向一个项
            ptree指向一个已初始化的树 */
/*后置条件  如果在树中找到指定项，该函数返回true，否则返回false*/
bool InTree(const Item * pi, const Tree * ptree);


/*操作    从树中删除一项*/
/*前提条件  pi是删除项的地址
            ptree指向一个已初始化的树 */
/*后置条件  从树中成功删除一个项，该函数返回true，否则返回false*/
bool DeleteItem(const Item * pi, Tree * ptree);


/*操作    把函数应用于树中的每一项*/
/*前提条件  ptree指向一个已初始化的树
            pfunc 指向一个函数，该函数接受一个Item类型的参数，并且没有返回值*/
/*后置条件  pfunc指向的这个函数为树中的每一项执行一次*/
void Traverse(const Tree * ptree, void (*pfunc) (Item item));


/*操作    删除树中的所有内容*/
/*前提条件  ptree指向一个已初始化的树 */
/*后置条件  树为空*/
void DeleteAll(Tree * ptree);


#endif // TREE_H_INCLUDED

.
.
二、tree.c

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include"tree.h"

//局部数据类型
typedef struct pair
{
    Trnode * parent;
    Trnode * child;
} Pair;

//局部函数的原型
static Trnode * MakeNode(const Item * pi);
static bool ToLeft(const Item * i1, const Item * i2);
static bool ToRight(const Item * i1, const Item * i2);
static void AddNode(Trnode * new_node, Trnode * root);
static void InOrder(const Trnode * root, void (*pfunc)(Item item));
static Pair SeekItem(const Item * pi, const Tree * ptree);
static void DeleteNode(Trnode **ptr);
static void DeleteAllNodes(Trnode * root);

/*函数定义*/
void InitiallizeTree(Tree * ptree)
{
    ptree->root = NULL;
    ptree->size = 0;
}

bool TreeIsEmpty(const Tree * ptree)
{
    if(ptree->root == NULL)
    {
        return true;
    }
    else
    {
        return false;
    }
}

bool TreeIsFull(const Tree * ptree)
{
    if(ptree->size == MAXITEMS)
    {
        return true;
    }
    else
    {
        return false;
    }
}

int TreeItemCount(const Tree * ptree)
{
    return ptree->size;
}

bool AddItem(const Item * pi,Tree * ptree)
{
    Trnode * new_node;
    if(TreeIsFull(ptree))
    {
        fprintf(stderr,"Tree is full\n");
        return false;
    }
    if(SeekItem(pi,ptree).child != NULL)
    {
        fprintf(stderr,"树中已经存在相关内容！\n");
        return false;
    }
    new_node = MakeNode(pi);
    if(new_node == NULL)
    {
        fprintf(stderr,"can't create node\n");
    }
    ptree->size++;

    if(ptree->root == NULL)
    {
        ptree->root = new_node;
    }
    else
    {
        AddNode(new_node,ptree->root);
    }
    return true;
}

static bool ToLeft(const Item * i1, const Item * i2) //列出仅有的返回true的两种情况，其余都是返回false，编程思想，局部思考
{
    int comp1;
    if( (comp1 = strcmp(i1->petname,i2->petname) ) < 0)
    {
        return true;
    }
    else if(comp1==0 && strcmp(i1->petkind,i2->petkind) < 0)
    {
        return true;
    }
    else
        return false;
}

static bool ToRight(const Item * i1, const Item * i2)
{
    int comp1;
    if( (comp1 = strcmp(i1->petname,i2->petname) ) > 0)
    {
        return true;
    }
    else if(comp1==0 && strcmp(i1->petkind,i2->petkind) > 0)
    {
        return true;
    }
    else
        return false;

}

static Pair SeekItem(const Item * pi, const Tree * ptree)
{
    Pair  pair;
    pair.parent = NULL;
    pair.child = ptree->root;

    if(TreeIsEmpty(ptree))
    {
        fprintf(stderr,"Tree is empty");
        return pair;
    }
    while(pair.child != NULL)
    {
        if(ToLeft(pi,&(pair.child->item) ))
        {
            pair.parent = pair.child;
            pair.child = pair.child->left;
        }
        else if(ToRight(pi,&(pair.child->item) ))
        {
            pair.parent = pair.child;
            pair.child = pair.child->right;
        }
        else
            break;
    }
    return pair;
}

static Trnode * MakeNode(const Item * pi)
{
    Trnode * new_node;
    new_node = (Trnode *)malloc(sizeof(Trnode));
    if(new_node != NULL)
    {
        new_node->item = *pi;
        new_node->left = NULL;
        new_node->right = NULL;
    }
    return new_node;
}

static void AddNode(Trnode * new_node, Trnode * root)
{
    Trnode * temp;
    if(ToLeft( &(new_node->item),&(root->item) ) )
    {
        temp  = root->left;
        if(temp != NULL)
        {
            AddNode(new_node,temp);
        }
        else{bool InTree(const Item * pi, const Tree * ptree);
            root->left = new_node;
        }
    }
    else if(ToRight( &(new_node->item),&(root->item) ) )
    {
        temp = root->right;
        if(temp != NULL)
        {
            AddNode(new_node,temp);
        }
        else{
            root->right = new_node;
        }
    }
    else{
        fprintf(stderr,"怎么重复了呢小老弟\n");
        exit(EXIT_FAILURE);
    }

}

bool InTree(const Item * pi, const Tree * ptree){
    return (SeekItem(pi,ptree).child != NULL) ? true:false;
}

bool DeleteItem(const Item * pi, Tree * ptree){
    Pair pair;
    pair = SeekItem(pi,ptree);
    if(pair.child == NULL){
        return false;
    }

    if(pair.parent == NULL){
        DeleteNode(&(ptree->root) );
    }
    else if(pair.parent->left == pair.child){
        DeleteNode(&(pair.parent->left) );
    }
    else{
        DeleteNode(&(pair.parent->right));
    }
    ptree->size--;
    return true;
}

static void DeleteNode(Trnode **ptr){
    Trnode * temp;
    if((*ptr)->left == NULL)
    {
        temp = *ptr;
        *ptr = (*ptr)->right;
        free(temp);
    }
    else if((*ptr)->right == NULL)
    {
        temp = *ptr;
        *ptr = (*ptr)->left;
        free(temp);
    }
    else{//被删除的节点有两个子节点
        for(temp = (*ptr)->left; temp->right!= NULL; temp = temp->right)
            continue;
        temp->right = (*ptr)->right;
        temp = *ptr;
        *ptr = (*ptr)->left;
        free(temp);
    }
}

//以下四个函数用到了分而治之的递归
void Traverse(const Tree * ptree, void (*pfunc) (Item item))
{
    if(ptree != NULL)
        InOrder(ptree->root,pfunc);
}

static void InOrder(const Trnode * root, void (*pfunc)(Item item))
{
    if(root != NULL)
    {
        InOrder(root->left,pfunc);
        (*pfunc)(root->item);
        InOrder(root->right,pfunc);
    }
}

void DeleteAll(Tree * ptree)
{
    if(ptree != NULL)
    {
        DeleteAllNodes(ptree->root);
    }
    ptree->root = NULL;
    ptree->size = 0;
}


static void DeleteAllNodes(Trnode * root)
{
    Trnode * pright;

    if(root != NULL)
    {
        pright = root->right;
        DeleteAllNodes(root->left);
        free(root);
        DeleteAllNodes(pright);
    }
}

.
.
三、main.c

#include <stdio.h>
#include <stdlib.h>
#include<string.h>
#include<ctype.h>
#include"tree.h"

char menu(void);
void addpet(Tree * pt);
void droppet(Tree * pt);
void showpets(const Tree * pt);
void findpet(const Tree * pt);
void printitem(Item item);
void uppercase(char * str);
char * s_gets(char * st, int n);

int main(void)
{
    Tree pets;
    char choice;

    InitiallizeTree(&pets);
    while((choice = menu()) != 'q')
    {
        switch(choice)
        {
        case 'a':
            addpet(&pets);
            break;
        case 'l':
            showpets(&pets);
            break;
        case 'f':
            findpet(&pets);
            break;
        case 'n':
            printf("%d pets in club\n",TreeItemCount(&pets));
            break;
        case 'd':
            droppet(&pets);
            break;
        default:
            puts("Switching error");
        }
    }
        DeleteAll(&pets);
        puts("Bye");
        return 0;
}

char menu(void)
{
    int ch;

    puts("Nerfville pet Club Membership Program");
    puts("Enter the letter corresponding to your choice:");
    puts("a) add a pet        l) show list of pets");
    puts("n) number of pets    f) find pets");
    puts("d) delete a pet       q) quit");
    //printf("%d",SLEN);
    while((ch = getchar()) != EOF)
    {
        while(getchar()!='\n')
            continue;
        ch = tolower(ch);
        if(strchr("alrfndq",ch) == NULL)
            puts("Please enter an a,l,f,n,d,or q");
        else
            break;
    }
    if(ch == EOF)
        ch = 'q';
    return ch;
}

void addpet(Tree * pt)
{
    Item temp;
    if(TreeIsFull(pt))
        puts("No room in the club!");
    else{
        puts("Please enter name of pet");
        s_gets(temp.petname,SLEN);
        printf("%s\n",temp.petname);
        puts("Please enter pet kind");
        s_gets(temp.petkind,SLEN);
        uppercase(temp.petname);
        uppercase(temp.petkind);
        AddItem(&temp,pt);
    }
}

void showpets(const Tree * pt)
{
    if(TreeIsEmpty(pt))
    {
        puts("No entries");
    }
    else
    {
        Traverse(pt,printitem);
    }
}

void printitem(Item item)
{
    printf("Pet: %-19s Kind: %-19s\n",item.petname,item.petkind);
}

void findpet(const Tree * pt)
{
    Item temp;

    if(TreeIsEmpty(pt))
    {
        puts("No entries");
        return;
    }

    puts("Please enter name of pet you wish to find:");
    s_gets(temp.petname,SLEN);
    puts("Please entet pet kind:");
    s_gets(temp.petkind,SLEN);
    uppercase(temp.petname);
    uppercase(temp.petkind);
    printf("%s the %s ",temp.petname,temp.petkind);
    if(InTree(&temp,pt))
        printf("is a member.\n");
    else
        printf("is not a member.\n");
}

void droppet(Tree * pt)
{
    Item temp;

    if(TreeIsEmpty(pt))
    {
        puts("No entries");
        return;
    }

    puts("Please enter name of pet you wish to delete:");
    s_gets(temp.petname,SLEN);
    puts("Please enter pet kind");
    s_gets(temp.petkind,SLEN);
    uppercase(temp.petname);
    uppercase(temp.petkind);
    printf("%s is %s ",temp.petname,temp.petkind);
    if(DeleteItem(&temp,pt))
        printf("is dropped from the club.\n");
    else
        printf("is not a member.\n");
}


void uppercase(char * str)
{
    while(*str){
        *str = toupper(*str);
        str++;
    }
}

char * s_gets(char * st, int n)
{
    char * ret_val;
    char * find;
    ret_val = fgets(st,n,stdin);
    if(ret_val)
    {
        find = strchr(st,'\n');
        if(find)
        {
            *find = '\0';
        }
        else
            while(getchar() != '\n')
                continue;
    }
    return ret_val;
}

四、总结：

①：其实其中有写函数的形参可以写成其它形式
②：tree.c文件（包含程序相关操作的函数实现），的第210行和第213行。
DeleteNode()函数中的参数绝对不能写pair.child，只能写成相应的pair.parent.xx。
为什么呢？
你想啊，pair.parent.xx 就是 pair.child，这个意思是pair的父节点的左子节点或者右子节点就是所查询到的look结构体对象的child部分（也就是你想要删除的那个树中的节点）。
意思就是你只能通过传入&pair.parent.xx才能达到使得在删除操作结束后被删除节点的父节点指向被删除节点的左子节点上的效果。而你传入&pair.child只是改变了被删除节点，但是被删除节点的父节点的指向还是原来的那个被删除节点！

以下面的程序来帮助理解第二点：
代码如下：

#include <stdio.h>
#include <stdlib.h>
typedef struct node{
    int item;
    struct node * next;
} Node;

void benext(Node ** node);
int main(void)
{
    Node n1 = {
    1,
    NULL
    };

    Node n2 = {
    2,
    NULL
    };

    Node n3 = {
    3,
    NULL
    };

    n1.next = &n2;
    n2.next = &n3;

    Node * dot = &n1;
    Node * a = dot->next;

    printf("%p\n",dot->next);
    printf("%p\n",a);
    printf("%p\n",dot->next->next);

    benext(&a);

    printf("===========\n");
    printf("%d\n",n1.next->item);
    printf("%d\n",dot->next->item);
    printf("%d\n",a->item);

    puts("===============");
    printf("%p\n",dot->next);
    printf("%p\n",a);

    return 0;
}


void benext(Node ** node){

    *node = (*node)->next;
    printf("benext()函数中的输出为：%d\n",(*node)->item);
}

运行截图如下：
请添加图片描述
分析：
本程序的本意是使链表中的第一项跳过第二项直接指向第三项
看代码：
（以下与运行截图中的输出顺序对应）
第32行：代表链表中第二个节点的地址
第33行：因为第30行的赋值表达式语句的影响，使得33行输出了和32行一样的地址
第34行：代表链表中第三个节点的地址
因为要改变指针，所以benext()函数的参数使二级指针（指向指针的指针），理所当然，函数的输出是3。

你以为通过第30行的赋值表达式，就能使得你的目的达到。
但是第39行和40行的输出还是2！，并且第一个节点的next指针的值（next指针所指向的节点的地址没有变）也就是说，第一个节点所指向的下一个节点还是第二个节点，
与之相反，你看到指针a的地址变为原先链表中的第三个节点的地址，指针a可以得到第三个节点的item值3。

所以就是说，这个程序只是单单改变了指针a，并没有改变原先列表中的第一个节点的next指针所指向的节点，纵使有第30行的赋值表达式。

当然，你写的代码多了，这种问题自然一看便能看出。
.

注意，还没完！

有些同学可能看到tree.c文件中的DeleteNode(Trnode **ptr)函数中， 也就是tree.c文件中的第262行，temp->right = (*ptr)->right; 他可能会觉得，这个语句有问题，不能达到预计的效果.（这个在二叉查找树的节点插入函数AddNode()中同样也存在）。

我想说的是，他现在脑袋可能会有点晕，别担心，我一开始也晕。下面来解决这个疑惑！ 其实，刚才我们讲的是两个指针，它们都指向同一处地方（即两个指针相同），但是，其中一个指针发生了改变（改变指针要传入指针的地址，再解引用，来改变）并不能使得，另一个开始与它相同的指针发生改变！,也就是说，你想要哪个指针发生改变，你要仔细想好，最好是遵循最原本的意思来编写代码。

但是，你看看上面那个表达式，只是借助传来参数的解引用来进行一个遍历而已，该temp指针代表了最后循环结束后的那个被删除节点的左子树的右下角的那个叶子节点，这是利用了多个指针可以（相互赋值）以指向同一个地址的性质，并没有改变指针，再者，上面的语句写成这样：(*temp).right = (*ptr).right，会不会更好理解呢？,其实啊，这就是通过节点指针（Node *）来改变节点(Node)而已啦！，你觉得Node*用来改变Node不是合情合理吗？？，完事了，ok，家人们。

对于这个疑惑，看下面的代码可以更好的理解：

#include <stdio.h>
#include <stdlib.h>
typedef struct node{
    int item;
    struct node * next;
} Node;

int main(void)
{
    Node n1 = {
    1,
    NULL
    };

    Node n2 = {
    2,
    NULL
    };

    Node * temp1 = &n1;
    Node * temp2 = temp1;
    temp2->next = &n2;

    printf("%d",n1.next->item);
    return 0;
}

运行截图如下：
在这里插入图片描述
这个留给你自己看，自己想咯！

关于更改指针需要传入指向指针的指针，看这个：
这个

菩提one
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
二叉搜索树（C语言实现）超级简洁版
weixin_45983489的博客
03-20 597
数据结构设计 #define BST_NODE_CHILD 0 #define BST_NODE_PARENT 1 //bst的节点 typedef struct bst_node { //关键字 int key; //左孩子 bst_node* left; //右孩子 bst_node* right; }bst_node; //bst树 typedef struct bst { //树的节点 struct bst_node* root; //记录树的节点数目 int size; }
c语言二叉搜索树
weixin_43790360的博客
09-09 381
1.二叉搜索树定义： 1）非空左子树的所有键值小于其根结点的键值； 2）非空右子树的所有键值大于其根结点的键值； 3）左、右子树都是二叉搜索树 4）二叉搜索树可以为空 2.二叉搜索树的查找操作Find：在二叉搜索树中查找关键字为X的结点，返回其所在结点的地址。 1）查找从树的根结点开始，如果树为空，返回NULL，表示未找到关键字为X的结点。 2）搜索树非空，则根结点关键字和X进行比较，依据比较结果，需要进行不同的处理： （1）若X大于根结点的关键字，满足条件的结点将不会出现在它的左子树，接下来的搜索只需要在
二叉查找树--C语言
weixin_52321645的博客
11-10 2237
二叉查找树要求，在树中的任意一个节点，其【左子树】中的每个节点的值，都要【小于】这个节点的值，而【右子树】节点的值都【大于】这个节点的值。 1. 头文件 1.1 include 1.2 定义树是否为空 1.3 树的数据结构 1.4 节点结构体 1.5 树结构体 #include<stdio.h> #include<string.h> #include<stdlib.h> /*树是否为空*/ #define bstree_is_empty(tree)(tr.
C/C++数据结构（十）—— 二叉查找树
热门推荐
Edison's 小宇宙
01-13 2万+
二叉查找树（Binary Search Tree），也称二叉排序树或二叉搜索树。
数据结构：二叉搜索树(图文并茂哦~)
最新发布
月临水的博客
05-16 1123
1.二叉搜索树的概念 二叉搜索树的结构代码 2.二叉搜索树的查找 二叉搜索树的查找代码 3.二叉搜索树的插入 二叉搜索树的插入代码 4.二叉搜索树的删除 二叉搜索树的删除代码 5.二叉搜索树的查询性能分析 6. 全部代码
C语言数据结构---二叉树(搜索树)
weixin_53825702的博客
06-07 146
这是C语言数据结构中的树形结构---二叉树,而本套代码是最为常用的二叉搜索树, 包含了创建,插入,遍历,搜索,删除二叉树中的元素的功能,已经测试无bug; 其中巧妙的递归方法的运用可以改善我们的思维
c语言实现二叉查找树实例方法
12-26
JJDiaries(阿呆) 邮箱：JJDiaries@gmail.com日期: 2013-11-13============================================二叉查找树，支持的操作包括：SERACH、MINIMUM、MAXIMUM、PREDECESSOR、SUCCESSOR、INSERT、DELETE。
C语言 二叉查找树性质详解及实例代码
01-21
二叉查找树性质 1、二叉树 每个树的节点最多有两个子节点的树叫做二叉树。 2、二叉查找树 一颗二叉查找树是按照二叉树的结构来组织的，并且满足一下性质： 一个节点所有左子树上的节点不大于盖节点，所有右子树的...
C语言二叉排序（搜索）树实例
12-31
本文实例为大家分享了C语言二叉排序（搜索）树实例代码，供大家参考，具体内容如下 /**1.实现了递归 非递归插入（创建）二叉排序（搜索）树； 分别对应Insert_BinSNode(TBinSNode* T,int k),NonRecursion_Insert_...
C语言经典算法之二叉树查找（递归实现）
weixin_56154577的博客
02-03 1157
在C语言中，二叉查找树（BST, Binary Search Tree）的查找算法可以通过递归方式实现。
C语言 树表的查找 代码实现
kstaaaaa的博客
03-02 136
二叉排序树、二叉排序树——递归查找
C语言之二叉查找树
Jiangtagong的博客
08-27 989
对于树的基本认识，我们很容易通过我们平常所见到的树来理解：一棵树，有一个根，根往上又会分叉出大树枝，大树枝又会分叉出小树枝，以此往复，直到最后是叶子。而作为数据结构的树也是类似的，只不过我们通常将它倒着画。树的应用也相当广泛，例如在文件系统，数据库索引中的应用等。本文会对树的基本概念做介绍，但重点介绍二叉查找树。 软件是通过数据和算法实现对现实世界的抽象，具有层次关系的数据在现实世界中能找到很多实例，比如： 公司组织架构：董事长-CXO-总监-经理-主管-员工； 中国行政区域划分：中国-省-市（县）-.
《算法导论》学习（十五）----二叉搜索树（C语言）
weixin_52042488的博客
09-19 471
本文主要讲解了二叉搜索树，并且用C语言是实现了它的所有基本操作函数，给出了C语言代码
二叉搜索树详解——附加C语言代码实现
likunkun__的博客
08-31 2255
二叉搜索树： 对于树中的每个节点X，它的左子树中所有项的值都小于X，右子树所有值都大于X，并且没有重复。 一、构造树： 树可以由一个个的节点构成，所以先定义节点结构体，和数据类型变量重命名 typedef int BSTDataType; typedef struct BSTreeNode { struct BSTreeNode* _left; struct BSTreeNode*...
二叉排序树（BST）查找算法详解之C语言版
sunnyoldboy博客
10-04 3548
在二叉排序树上查找某个结点，其实就是遍历二叉树。由于二叉排序树上的结点是有序的，因此不需要使用普通二叉树的遍历算法，其有自己一套简单的遍历算法，即从树根开始进行遍历，如果待查找元素小于树根元素，则向左遍历，否则向右遍历，如果相等结束遍历。
js中取子节点（table表）
qq_27939357的博客
05-08 3932
最近在慕课网上学习js，一路都很顺畅，今天学到获取子节点这里，遇到了一点小问题； 转自慕课网javascript进阶篇9-22节的其他同学的源代码如下实现的效果就是鼠标经过表的每一行时候每一行的背景色改变；其他学都是跟tag那么获取所有的行（tr）     new document                     window.onload = function
数据结构通用树
wangzhencu的博客
05-23 677
今天来看大家介绍树，树是一种非线性的数据结构，树是由n个结点组成的有限集合，如果n=0,称为空树；如果n>0，则：有一个特定的称之为根的结点，它只有直接后继，但没有直接前驱；除根以外的其他结点划分为m个互不相交的有限集合，每个集合又是一棵树，并且称之为根的子树。       如图                      树的一些基本概念 l
TreeView 根据节点value值即名称找到该节点
cn_514的博客
03-27 3281
欢迎加群交流 QQ群 830426796 //根据节点名称找到对应的节点信息 public TreeNode FindNodeByValue(TreeNodeCollection trCollection, string szTxtName ) { TreeNode trNode= null; ...
c语言 二叉排序树的查找算法
01-08
下面是一个具体的C语言实现二叉排序树查找算法的例子： ```c #include #include // 定义二叉排序树的节点结构 typedef struct BSTNode { int data; struct BSTNode* left; struct BSTNode* right; } BSTNode;...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

菩提one

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值