C语言实现二叉树---＞二叉查找树

最新推荐文章于 2023-03-29 00:32:06 发布
最新推荐文章于 2023-03-29 00:32:06 发布
阅读量822 收藏 2
点赞数
分类专栏： C语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuge1123/article/details/115765206
版权

声明

代码实现都是自己写的，而且没有借鉴别人的代码，也没有看任何教程，只看了下二叉树的具体定义，知道大概是个什么东西
说这些只是为了说明下列代码实现肯定不是最优的，甚至在你们看来都是很垃圾的代码，不过没关系，因为这是我自己动脑筋写出来的，记录一下
ps: 我C语言功底不好，才学几天

定义

二叉查找树是二叉树中最简单的了

  1. 若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；

  2. 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；

  3. 任意节点的左、右子树也分别为二叉查找树。

  4. 没有键值相等的节点（no duplicate nodes）。

在这里插入图片描述

假设有一个节点，这个节点的左右节点都有值，那么它左边的节点一定小于它本身，它右边的节点一定大于它本身，就和上面的图一样 （我这里实现了可以有相同元素，相同的元素会放到右子树）

C语言实现

分别创建三个文件

  1. bin_tree.h
  2. bin_tree.c
  3. bin_tree_main.c

bin_tree.h


#pragma once

#ifndef __BIN_TREE_HEAD_FILE__

#define __BIN_TREE_HEAD_FILE__

#include <stdio.h>
#include <stdlib.h>



typedef struct _node Node;


typedef struct _tree Tree;

typedef int BOOL;

#define TRUE 1

#define FALSE 0

Tree* Tree_create();

void add(Tree *self, int data);

BOOL remove_data(Tree *self, int data);

void foreach(Tree *self, void (*callback)(int data));

Node* find_node(Node *root, int data);

static void add_node(Node *root, Node *node);

static void foreach_node(Node *root, void (*callback)(int data));

static BOOL remove_node(Node *node, Node *del_node);

static Node* get_node();

Node *find_max_node(Node *root);

void delete_node(Node **node);

int if_left_or_right(Node *node);

#endif

bin_tree.c

注意下，删除节点的方法的返回值不可用，就是没有赋值正确的值，读者拿到代码后可以自己实现下


#include "bin_tree.h"

typedef struct _node
{
    struct _node *right; // 左子树
    struct _node *left; // 右子树
    struct _node *parent; // 父节点
    int data; //保存的数据
}Node;


typedef struct _tree
{
    Node *root;
}Tree;


Tree* Tree_create()
{
    Tree *tree = (Tree*) malloc(sizeof(Tree));
    tree->root = NULL; // 初始化内存
    return tree;

}

Node *find_max_node(Node *root)
{
    Node *result = root;
    if( root && root->right )
    {
        result = find_max_node(root->right);
    }

    return result;
}

void delete_node(Node **node)
{
    free(*node);
    *node = NULL;

}

// 判断当前节点是处于左子树还是右子树
// 位于左子树返回 1
// 位于右子树返回 2
// 返回 0 没有根节点
int if_left_or_right(Node *node)
{
    int result = 0;
    if( !node->parent )
    {
        result = 0;
    } else if( node == node->parent->left )
    {
        result = 1;
    } else if( node == node->parent->right )
    {
        result = 2;
    }
    
    return result;
}

void add(Tree* self, int data)
{
    Node *c = get_node();
    c->data = data;
    if( self->root )
    {
        add_node(self->root, c);
    } else 
    {
        self->root = c;
    }

}

BOOL remove_data(Tree* self, int data)
{   BOOL result = FALSE;
    Node *root = self->root;
    if( !root )
    {
        return result;
    }

    // 找到要删除的节点
    Node *del_node = find_node(root, data);
    if( !del_node )
    {
        return result;
    }
 

    if( root == del_node && !del_node->left && !del_node->right ) // 只有根节点
    {
        self->root = NULL;
        delete_node(&root);
    } else if( root == del_node && root->left )
    {
        Node *max_node = find_max_node(root->left);
        self->root = max_node;
        if( max_node != root->left ) 
        {
            max_node->parent->right = max_node->left;
            max_node->left = root->left;
            //root->left->parent = max_node;
        }  
        max_node->right = root->right;
        max_node->parent = NULL;
        root->left->parent = max_node;
        if( root->right )
        {
            root->right->parent = max_node;    
        }
        delete_node(&root);
    } else if( root == del_node && root->right )
    {
        self->root = root->right;
        root->right->parent = NULL;
        delete_node(&root);
    } else
    {
        result = remove_node(self->root, del_node);
    }

    return result;
}

void foreach(Tree* self, void (*callback)(int data))
{

    if( self->root )
    {
        foreach_node(self->root, callback);
    }

}

static void add_node(Node* root, Node* node)
{
    if( node->data >= root->data && !root->right )
    {
        root->right = node;
        node->parent = root;
    } else if( node->data < root->data && !root->left )
    {
        root->left = node;
        node->parent = root;
    } else if( node->data >= root->data )
    {
        add_node(root->right, node);
    } else if( node->data < root->data )
    {
        add_node(root->left, node);
    }
}

Node* find_node(Node* root, int data)
{
    Node *result = NULL;
    if( !root )
    {
        return result;
    }
    if( data == root->data )
    {
        result = root;
    } else if( data > root->data && root->right )
    {
        result = find_node(root->right, data);
    } else if( root->left )
    {
        result = find_node(root->left, data);
    }

    return result;

}

static void foreach_node(Node* root, void (*callback)(int data))
{
    if( root->left )
    {
        foreach_node(root->left, callback);
    }
    callback(root->data);
    if( root->right )
    {
        foreach_node(root->right, callback);
    }
}

static BOOL remove_node(Node *node, Node *del_node)
{

   // 如果当前节点没有任何子节点则直接删除
    if( !del_node->left && !del_node->right )
    {
        if( if_left_or_right(del_node) == 1 )
        {
            del_node->parent->left = NULL;
            delete_node(&del_node);
            
        } else if ( if_left_or_right(del_node) == 2 )
        {
            del_node->parent->right = NULL;
            delete_node(&del_node);
        }
    }
    // 如果当前节点有右节点或者左节点则让他的父节点指向它的孩子节点
    else if( del_node->left && !del_node->right )  // 有左子树但没有右子树
    {  

        if( if_left_or_right(del_node) == 1 )
        {
            del_node->parent->left = del_node->left;
        } else if( if_left_or_right(del_node) == 2 )
        {
            del_node->parent->right = del_node->left;
        }
        del_node->left->parent = del_node->parent;
        delete_node(&del_node);
    }
    else if( del_node->right && !del_node->left )  // 有右子树但没有左子树
    {
        if( if_left_or_right(del_node) == 1 )
        {
            del_node->parent->left = del_node->right;
        } else if( if_left_or_right(del_node) == 2 )
        {
            del_node->parent->right = del_node->right; 
        }
        del_node->right->parent = del_node->parent;
        delete_node(&del_node);
    }
    // 如果当前节点又有左节点又有右节点则需要找到要删除节点左子树中最大的节点
    // 然后再删除当前节点
    else if( del_node->left && del_node->right )
    {
        // 找到要删除的左子树的最大节点
        Node *max_node = find_max_node(del_node->left);
        if( if_left_or_right(del_node) == 1 )
        {
            del_node->parent->left = max_node;
            if( del_node->left != max_node )
            {
                max_node->parent->right = max_node->left; // 最大节点肯定是在它父节点的右边，且最大节点没有右子树
                max_node->left = del_node->left;
                del_node->left->parent = max_node;
            }
            max_node->right = del_node->right;
            del_node->right->parent = max_node;

            delete_node(&del_node);
        } else if( if_left_or_right(del_node) == 2 )
        {
            del_node->parent->right = max_node;
            if( del_node->left != max_node )
            {
                max_node->parent->right = max_node->left; // 最大节点肯定是在它父节点的右边，且最大节点没有右子树
                max_node->left = del_node->left;
                del_node->left->parent = max_node;
            }
            max_node->right = del_node->right;
            del_node->right->parent = max_node;
            delete_node(&del_node);
 
        }
    }

    return TRUE;
}

static Node* get_node()
{
    Node *node = (Node*) malloc(sizeof(Node));
    node->right = NULL;
    node->left = NULL;
    node->parent = NULL;
    return node;

}

bin_tree_main.c

#include "bin_tree.h"

void print(int data);


int main()
{
    Tree* tree = Tree_create();
    add(tree, 11);
    add(tree, 1);
    add(tree, 12);
    add(tree, 15);
    add(tree, 14);
    add(tree, 9);
    foreach(tree, print);
    printf("删除节点之后再遍历\n");
    remove_data(tree, 15);
    remove_data(tree, 9);
    remove_data(tree, 11);
    remove_data(tree, 1);
    remove_data(tree, 12);
    foreach(tree, print);
    return 0;
}

void print(int data)
{
    printf("%d\n", data);
}

在这里插入图片描述

子♂衿
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉查找树（C语言实现）创建、增加节点、删除节点、查找前趋和后继、查找节点、遍历
WjyId123的博客
07-05 1388
二叉查找树满足以下性质：若x为根（树或者子树），若y是x的左子树上的节点，则value(y)<value(x)，若y是x的右子树上的节点，则value(y)>value(x)。 使用二叉查找树进行查找时，平均的查找时间为O(lgn)，最坏的查找时间为O(n)。 根据二叉树的定义可以得出以下结论： （1）对二叉查找树进行中序遍历会得到一个有序的序列。 （2）若二叉查找树中的某个结点有两个子女，则其后继没有左子女，其前趋没有右子女。 二叉查找树结构体定义： typedef struc.
C语言之二叉查找树
Jiangtagong的博客
08-27 993
对于树的基本认识，我们很容易通过我们平常所见到的树来理解：一棵树，有一个根，根往上又会分叉出大树枝，大树枝又会分叉出小树枝，以此往复，直到最后是叶子。而作为数据结构的树也是类似的，只不过我们通常将它倒着画。树的应用也相当广泛，例如在文件系统，数据库索引中的应用等。本文会对树的基本概念做介绍，但重点介绍二叉查找树。 软件是通过数据和算法实现对现实世界的抽象，具有层次关系的数据在现实世界中能找到很多实例，比如： 公司组织架构：董事长-CXO-总监-经理-主管-员工； 中国行政区域划分：中国-省-市（县）-.
C语言算法二叉查找树基本操作
qq_51553982的博客
05-27 2105
二叉查找树：左子<根结点<右子的二叉树 基本实现有插入，删除，中序遍历，寻找结点，用这些可以写出其他的功能，比如寻找到最大的结点然后删除，在二叉查找树中替换部分子树等。 直接看代码： #include<stdlib.h> #include<stdio.h> #include<malloc.h> #include<string.h> //二叉查找（搜索）树定义：左子节点<右子节点<根节点 //创建方式和普通二叉树相同 //创建结构 t
链式二叉树的基本操作(C语言实现)
Brant_zero的博客
07-05 1474
本篇博客学习的是最普通的链式二叉树，这个结构在实际应用的中的作用并不是很大，但是我们仍要学习这个结构。学习这个结构的目的是为了以后我们研究更复杂的树型结构打下基础。废话不多说，直接开始。...
二叉查找树（c语言实现）
schoolers的专栏
03-30 2954
二叉查找树（Binary Search Tree），或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。 二叉排序树的查找过程和次优二叉树类似，通常采取二叉链表作为二叉排序树的存储结构。中序遍历 二叉排序树可得到一个关键字的
基于C语言实现二叉树-堆-图（数据结构实验）【100012026】
04-25
本实验“基于C语言实现二叉树-堆-图（数据结构实验）”着重于三种基本数据结构：二叉树、堆和图，并探讨了它们在实际问题中的应用。 首先，我们来深入理解二叉树。二叉树是一种特殊的树形数据结构，每个节点最多有...
二叉树-基于C语言实现的二叉树基本操作.zip
最新发布
04-26
2. **插入节点**：根据二叉树的性质（如二叉搜索树）选择合适的位置插入新节点。 ```c Node* insertNode(Node* root, int data) { if (root == NULL) { root = createNode(data); } else if (data < root->data)...
c语言实现二叉查找树实例方法
09-04
二叉查找树（Binary Search Tree，BST）是一种自平衡的二叉树数据结构，它具有以下特性： 1. 每个节点包含一个键（key）、一个关联的值、一个指向左子节点的指针和一个指向右子节点的指针。 2. 节点的键大于其左...
C语言实现二叉查找树（BST）的基本操作
12-22
我们在上一篇博客中讲解了二叉树，这一次我们来实现二叉树的进阶——二叉查找树（Binary Search Tree），又称二插排序树(Binary Sort Tree)。所以简称为BST。二插查找树的定义如下： 　1.若左子树不为空，则左子树...
有用的C语言源代码-二叉树-链表-数组等
07-10
这里可能包含了二叉搜索树（BST）、完全二叉树、满二叉树、平衡二叉树（如AVL树或红黑树）等的实现，以及遍历（前序、中序、后序）和其他操作（插入、删除）的代码。 "字符串"是C语言中处理文本数据的重要部分。...
[数据结构]：20-线索二叉树（无头结点）（C语言实现）
Chandni_小月月
03-29 263
此专栏包含408考研数据结构全部内容，除其中使用到C++引用外，全为C语言代码。使用C++引用主要是为了简化指针的使用，避免二重指针的出现。
二叉排序树（BST）查找算法详解之C语言版
sunnyoldboy博客
10-04 3573
在二叉排序树上查找某个结点，其实就是遍历二叉树。由于二叉排序树上的结点是有序的，因此不需要使用普通二叉树的遍历算法，其有自己一套简单的遍历算法，即从树根开始进行遍历，如果待查找元素小于树根元素，则向左遍历，否则向右遍历，如果相等结束遍历。
c语言取根,二叉查找树C语言实现
weixin_39701861的博客
05-20 133
今天练习一下二叉查找树的东东，感觉这个东西，找前驱和后继结点有些绕，再通过后继结点实现删除，更需要好好想一想流程。参照算法导论经典，经过自己的思考，将其中提到的一些基本操作实现了。说明都在注释里呢，这边迷糊的童鞋可以看看，好好想一下。 (我写的都是naive版本的代码，仅供理解算法本身)/*一个关键字元素不重复的二叉查找树及其典型操作的实现，记录关键字出现次数*/#include #include...
二叉查找树--C语言
weixin_52321645的博客
11-10 2246
二叉查找树要求，在树中的任意一个节点，其【左子树】中的每个节点的值，都要【小于】这个节点的值，而【右子树】节点的值都【大于】这个节点的值。 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.
树——二叉树结点的查找
05-26 1489
1，查找方式： 1，基于数据元素值的查找： 1，BTreeNode<T>* find(const T& value) const 2，基于结点的查找： 1，BTreeNode<T>* find(TreeNode<T>* node) const ...
C语言-二叉树基本操作以及二叉搜索树基本操作
兴国的博客
01-07 1115
功能 二叉树操作: 创建二叉树 遍历二叉树(前序,中序,后续) 计算高度 计算结点数目 清空二叉树 空树判断 二叉搜索树操作: 插入 最值(最大值,最小值) 删除 代码 #include stdio.h> #include stdlib.h> #include stdbool.h> typedef struct _BinNode BinNode; struct _BinN
搜索二叉树 递归创建和非递归创建
weixin_A13253323604
09-14 162
#include <stdio.h> #include <stdlib.h> /*创建一颗 搜索二叉树 结构体*/ typedef struct TreeNode{ int data; struct TreeNode *leftTree; struct TreeNode *rightTree; }TreeNode; /*中序递归遍历*/ /* 递归的本质是压栈 */ void mid_travel(TreeNode *Node) { if(
C语言实现二叉树排序
Future_LL的博客
01-24 2584
一、代码 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define N 10 int a[N]={3,2,5,8,4,7,6,9,1,10}; typedef struct tree { int data; struct tree *lchild; struct tree *rchild; }BitTree; void S...
二叉查找树的查找、插入、删除、释放等基本操作的实现（C语言）
大树的专栏
06-14 8976
二叉查找树是一种特殊性质的二叉树，该树中的任何一个节点，它的左子树（若存在）的元素值小于节点的元素值，右子树（若存在）的元素值大于节点的元素值。 实现了二叉树查找树的实现以及基本操作，包括查找、插入、删除、初始化、释放等。 源码下载地址：http://download.csdn.net/detail/mcu_tian/9548788 二叉查找树节点的结构定义 相比二叉树，二叉查找树的元素结
c语言实现将二叉查找树变为有序的双向链表
11-10
以下是C语言实现将二叉查找树变为有序的双向链表的代码和注释说明： ```c #include <stdio.h> #include <stdlib.h> // 定义二叉树结构体 struct TreeNode { int val; struct TreeNode *left; struct TreeNode *...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值