【数据结构】（C语言）：二叉搜索树

已于 2024-07-01 10:18:04 修改
阅读量300 收藏 6
点赞数 5
分类专栏： 数据结构和算法 文章标签： 数据结构 c语言
于 2024-06-30 21:49:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yannan20190313/article/details/140086145
版权

二叉搜索树：

  • 树不是线性的，是层级结构。
  • 基本单位是节点，每个节点最多2个子节点。
  • 有序。每个节点，其左子节点都比它小，其右子节点都比它大。
  • 每个子树都是一个二叉搜索树。每个节点及其所有子节点形成子树。
  • 可以是空树。

添加元素：从根节点开始，比对数值。若比它小，往左子树比对；若比它大，往右子树比对；直到找到为空，则为新元素的位置。

删除元素：

  1. 若删除的节点为叶子节点（即无子节点），则直接删除。
  2. 若删除的节点只有左子节点，则左子节点替代删除节点。
  3. 若删除的节点只有右子节点，则右子节点替代删除节点。
  4. 若删除的节点既有左子节点又有右子节点，则找到直接前驱（即删除节点的左子树中的最大值，即删除节点的左子节点的最右节点），直接前驱的值替代删除节点的值，删除直接前驱节点。

清空树：从根节点开始遍历，依次从叶子节点开始 释放每个节点的内存空间，最终根节点指向NULL。

遍历元素：（可使用递归）

  • 前序遍历（顺序：根节点、左子节点、右子节点）。
  • 中序遍历（顺序：左子节点、根节点、右子节点）。
  • 后序遍历（顺序：左子节点、右子节点、根节点）。

查找元素：从根节点开始，比对数值。若比它小，往左子树查找；若比它大，往右子树查找；直到找到该元素，则返回1（true），若没有，则返回0（false）。

C语言实现：（使用链表实现）

 创建结构体数据类型（记录二叉搜索树的根节点和数据个数）：

typedef struct Link
{
	LinkNode *root;			// 根节点
	int length;			    // 统计有多少数据
} LinkBST;                  // 别名

创建二叉搜索树，并初始化：

LinkBST bst;
bst.root = NULL;    // 根节点，初始化为NULL
bst.length = 0;     // 数据个数，初始化为0

创建节点（结构体数据类型），并创建具体节点实例的函数：

// 节点（结构体数据类型）
typedef struct Node
{
	int value;			    // 数据类型为整型
	struct Node *left;		// 左子节点
	struct Node *right;		// 右子节点
}LinkNode;                  // 别名
// 函数：创建节点
LinkNode *createNode(int data)
{
	LinkNode *node = (LinkNode *)malloc(sizeof(LinkNode));    // 分配节点内存空间

	if(node == NULL)
	{
		perror("Memory allocation failed");
		exit(-1);
	}
	node->value = data;    // 数据
	node->left = NULL;     // 左子节点，初始化为NULL
	node->right = NULL;    // 右子节点，初始化为NULL
	return node;
}

添加元素：

void add(LinkBST *bst, int data)	// add element
{
	// 函数：往二叉搜索树中添加元素	
	LinkNode *addNode(LinkNode *node, int data)
	{
		if(node == NULL)
		{
			LinkNode *newnode = createNode(data);
			node = newnode;
			bst->length++;    // 每添加一个元素，length+1
			return node;
		}
		if(data < node->value) node->left = addNode(node->left, data);
		else if(data > node->value) node->right = addNode(node->right, data);
		return node;
	}

	// 从根节点开始比对，root指针始终指向二叉搜索树的根节点
	bst->root = addNode(bst->root, data);	
}

删除元素：

void delete(LinkBST *bst, int data)	// delete element
{
	// 函数：删除节点	
	LinkNode *del(LinkNode *node)
	{   
        // 若只有右子节点，则右子节点替代删除节点
		if(node->left == NULL)
		{
			bst->length--;        // 每删除一个元素，length-1
			return node->right;
		}
        // 若只有左子节点，则左子节点替代删除节点
		else if(node->right == NULL)
		{
			bst->length--;        // 每删除一个元素，length-1
			return node->left;
		}
        // 左右子节点都有，则直接前驱(左子节点的最右节点)替代删除节点，并删除直接前驱
		else if(node->left && node->right)
		{
			LinkNode *tmp = node, *cur = node->left;
			while(cur->right)
			{
				tmp = cur;
				cur = cur->right;
			}
			node->value = cur->value;
			if(tmp != node) tmp->right = cur->left;
			else tmp->left = cur->left;
			bst->length--;        // 每删除一个元素，length-1
			return node;
		}
	}

	// 函数：找到将要删除的节点
	LinkNode *delNode(LinkNode *node, int data)
	{
		if(node == NULL) return node;
		if(data == node->value) node = del(node);
		else if(data < node->value) node->left = delNode(node->left, data);
		else if(data > node->value) node->right = delNode(node->right, data);
		return node;
	}	
	
	// 从根节点开始比对。root指针始终指向二叉搜索树的根节点
	bst->root = delNode(bst->root, data);	
}

清空树：

void clear(LinkBST *bst)
{
	// 函数：释放每个节点的内存空间
	void clearNode(LinkNode *node)
	{
		if(node->left == NULL && node->right == NULL)
		{
			free(node);        // 使用malloc动态分配内存空间，不使用时需使用free释放内存空间
			node == NULL;      // 释放内存空间后，指针指向NULL，避免野指针
			return ;
		}
		if(node->left) clearNode(node->left);
		if(node->right) clearNode(node->right);
	}
	
	// 树非空，释放所有节点的内存空间，根节点为NULL，数据个数为0
	if(bst->root == NULL) return ;
	clearNode(bst->root);    // 从根节点开始遍历，依次从叶子节点开始释放内存空间
	bst->root = NULL;        // 根节点指向NULL
	bst->length = 0;         // 数据个数为0
}

遍历元素：（使用递归）

// 前序遍历（根，左，右）
void pretravel(LinkNode *node)
{
	if(node == NULL) return ;
	printf("%d  ", node->value);
	pretravel(node->left);
	pretravel(node->right);
}
// 中序遍历（左，根，右）
void midtravel(LinkNode *node)
{
	if(node == NULL) return ;
	midtravel(node->left);
	printf("%d  ", node->value);
	midtravel(node->right);
}
// 后序遍历（左，右，根）
void posttravel(LinkNode *node)
{
	if(node == NULL) return ;
	posttravel(node->left);
	posttravel(node->right);
	printf("%d  ", node->value);
}

查找元素：

找到元素，返回1(true)；没找到，返回0(false)。

int find(LinkNode *node, int data)
{
	if(node ==  NULL) return 0;
	if(data == node->value) return 1;
	if(data < node->value) find(node->left, data);
	else if(data > node->value) find(node->right, data);	
}

完整代码：（bst.c）

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

/* structure */
typedef struct Node			// linkedlist node
{
	int value;			    // value type is integer
	struct Node *left;		// left child node
	struct Node *right;		// right child node
}LinkNode;

typedef struct Link			// binary search tree
{
	LinkNode *root;			// root node of the tree
	int length;			    // the number of the tree
} LinkBST;

/* function prototype */
void add(LinkBST *, int);		// add element to the tree
void delete(LinkBST *, int);	// delete element from the tree
void clear(LinkBST *);			// clear the tree
void pretravel(LinkNode *);		// show element one by one,(root,left,right)
void midtravel(LinkNode *);		// show element one by one,(left,root,right)
void posttravel(LinkNode *);	// show element one by one,(left,right,root)
int find(LinkNode *, int);		// if find data,return 1(true),or return 0(false)

/* main function */
int main(void)
{
	// create binary search tree and initialization
	LinkBST bst;
	bst.root = NULL;
	bst.length = 0;
	printf("isempty(1:true, 0:false): %d, length is %d\n",  bst.root==NULL, bst.length);
	
	add(&bst, 15);
	add(&bst, 8);
	add(&bst, 23);
	add(&bst, 10);
	add(&bst, 12);
	add(&bst, 19);
	add(&bst, 6);
	printf("isempty(1:true, 0:false): %d, length is %d\n",  bst.root==NULL, bst.length);

	printf("midtravel: ");
	midtravel(bst.root);
	printf("\n");
	printf("pretravel: ");
	pretravel(bst.root);
	printf("\n");
	printf("posttravel: ");
	posttravel(bst.root);
	printf("\n");
	
	printf("find 10 (1:true, 0:false): %d\n", find(bst.root, 10));
	printf("find 9 (1:true, 0:false): %d\n", find(bst.root, 9));
	
	delete(&bst, 23);
	delete(&bst, 15);
	delete(&bst, 6);

	printf("isempty(1:true, 0:false): %d, length is %d\n",  bst.root==NULL, bst.length);
	printf("midtravel: ");
	midtravel(bst.root);
	printf("\n");
	printf("pretravel: ");
	pretravel(bst.root);
	printf("\n");
	printf("posttravel: ");
	posttravel(bst.root);
	printf("\n");

	clear(&bst);
	printf("isempty(1:true, 0:false): %d, length is %d\n",  bst.root==NULL, bst.length);
	return 0;
}

/* subfunction */
LinkNode *createNode(int data)		// create a node
{
	LinkNode *node = (LinkNode *)malloc(sizeof(LinkNode));

	if(node == NULL)
	{
		perror("Memory allocation failed");
		exit(-1);
	}
	node->value = data;
	node->left = NULL;
	node->right = NULL;
	return node;
}

void add(LinkBST *bst, int data)	// add element
{
	// subfunction(recursion): add element to the binary search tree	
	LinkNode *addNode(LinkNode *node, int data)
	{
		if(node == NULL)
		{
			LinkNode *newnode = createNode(data);
			node = newnode;
			bst->length++;
			return node;
		}
		if(data < node->value) node->left = addNode(node->left, data);
		else if(data > node->value) node->right = addNode(node->right, data);
		return node;
	}

	// root node receive the result
	bst->root = addNode(bst->root, data);	
}

void delete(LinkBST *bst, int data)	// delete element
{
	// subfunction(recursion): delete element from the binary search tree	
	LinkNode *del(LinkNode *node)
	{
		if(node->left == NULL)
		{
			bst->length--;
			return node->right;
		}
		else if(node->right == NULL)
		{
			bst->length--;
			return node->left;
		}
		else if(node->left && node->right)
		{
			LinkNode *tmp = node, *cur = node->left;
			while(cur->right)
			{
				tmp = cur;
				cur = cur->right;
			}
			node->value = cur->value;
			if(tmp != node) tmp->right = cur->left;
			else tmp->left = cur->left;
			bst->length--;
			return node;
		}
	}

	// subfunction: find delete node,return node
	LinkNode *delNode(LinkNode *node, int data)
	{
		if(node == NULL) return node;
		if(data == node->value) node = del(node);
		else if(data < node->value) node->left = delNode(node->left, data);
		else if(data > node->value) node->right = delNode(node->right, data);
		return node;
	}	
	
	// root node receive the result
	bst->root = delNode(bst->root, data);	
}

void clear(LinkBST *bst)		// clear the tree
{
	// function: free memory space on ecah node
	void clearNode(LinkNode *node)
	{
		if(node->left == NULL && node->right == NULL)
		{
			free(node);
			node == NULL;
			return ;
		}
		if(node->left) clearNode(node->left);
		if(node->right) clearNode(node->right);
	}
	
	// if not empty tree,free memory space on each node,root is NULL and length is 0
	if(bst->root == NULL) return ;
	clearNode(bst->root);
	bst->root = NULL;
	bst->length = 0;
}

void pretravel(LinkNode *node)		// show element one by one,(root,left,right)
{
	if(node == NULL) return ;
	printf("%d  ", node->value);
	pretravel(node->left);
	pretravel(node->right);
}

void midtravel(LinkNode *node)		// show element one by one,(left,root,right)
{
	if(node == NULL) return ;
	midtravel(node->left);
	printf("%d  ", node->value);
	midtravel(node->right);
}

void posttravel(LinkNode *node)		// show element one by one,(left,right,root)
{
	if(node == NULL) return ;
	posttravel(node->left);
	posttravel(node->right);
	printf("%d  ", node->value);
}

int find(LinkNode *node, int data)	// if find data,return 1(true),or return 0(false)
{
	if(node ==  NULL) return 0;
	if(data == node->value) return 1;
	if(data < node->value) find(node->left, data);
	else if(data > node->value) find(node->right, data);	
}

编译链接： gcc -o bst bst.c

执行可执行文件： ./bst

yannan20190313
关注
  • 5
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现二叉搜索树，可插入、删除搜索节点
06-27
C语言实现二叉搜索树，可插入、删除搜索节点，代码量只有100多行，注释详实，对萌新十分友好 博客地址：https://tinycool.blog.csdn.net/article/details/131423285
c语言实现二叉搜索树
03-23
1.实现二叉搜索树的基本操作 2.包括建立，查找，删除，显示 3.得到最长路径和最短路径，并能分别计算长度
数据结构 --- c语言二叉搜索树(有序的树)
weixin_60569662的博客
02-27 2592
二叉搜索树基础 左边孩子节点的值 < 父节点的值，右边孩子节点的值 > 父节点的值 每个二叉搜索树的子树也是一棵二叉搜索树 10 充当根节点 18 > 根节点，放在根节点右边；3 < 根节点，放在根节点左边；8 首先与根节点相比较，8 < 根节点，所以应该放在根节点的左边；然后 8 与 3 比较，3 < 8，8 应该放在 3 的右边，持续构建即可 二叉搜索树的特性：中序遍历是一个有序序列，从小到大排序，2-3-4-7-.
数据结构：二叉查找树
梁辰兴的博客
09-17 986
二叉查找树（Binary Search Tree，简称BST）是一种特殊的二叉树，其中每个节点都有一个可比较的键和一个关联的值，且对于每个节点，其左子树的所有键都小于节点的键，而右子树的所有键都大于节点的键。简介二叉查找树是一种自我平衡的二叉树，它的中序遍历会得到一个升序的序列。二叉查找树的每个节点都包含一个键和一个值，其中键用于保持树的排序，而值则可以是任何类型的数据。二叉查找树的主要操作包括插入、查找和删除。图示50/ \30 70/ \ / \
【零基础算法】C语言实现二叉搜索树
C_Ryson的博客
10-25 1583
本文为c语言实现二叉搜索树
C语言数据结构代码——二叉搜索树
qq_41862220的博客
04-28 282
Head.H #define ARRSIZE 6 typedef struct _tnode { int ele; struct _tnode *ltree; struct _tnode *rtree; }TNode, *tnode; void InsertTree(tnode T, int num); tnode InitSearchTree(int *a, int len); ...
binarytree:二叉搜索树
03-05
二叉搜索树（Binary Search Tree，简称BST）是一种特殊的二叉树数据结构，它具有以下特性： 1. **定义**：每个节点包含一个键（key）、一个关联的值、一个指向左子节点的引用和一个指向右子节点的引用。对于每个...
基于C语言的数据结构-二叉搜索树bitTree
06-25
在"基于C语言的数据结构-二叉搜索树bitTree"这个压缩包中，可能包含了实现上述操作的源代码示例。学习这些代码有助于深入理解二叉搜索树的工作原理和C语言的指针操作。通过实践和调试，你可以更好地掌握二叉搜索树在...
c语言实现二叉查找树实例方法
09-04
二叉查找树（Binary Search Tree，BST）是一种自平衡的二叉树数据结构，它具有以下特性： 1. 每个节点包含一个键（key）、一个关联的值、一个指向左子节点的指针和一个指向右子节点的指针。 2. 节点的键大于其左...
数据结构（初阶3.单链表）
2401_83968713的博客
07-14 653
一、单链表1.1概念与结构1.2结点1.3链表的性质1.4链表的打印二、实现单链表SList.hSList.c申请新节点尾插头插尾删头删在指定位置之前插入数据在指定位置之后插入数据删除指定位置结点删除指定位置之后的结点销毁结点test.c。
数据结构【顺序表】
qq_67578580的博客
07-12 1416
我们需要创建一个seqlist.h头文件，seqlist.c文件存放函数，还有一个.c的测试文件。
【数据结构】栈和队列
奋斗的小羊的博客
07-12 1823
栈超超超详解
数据结构第23节 线性搜索
hummhumm的专栏
07-12 403
线性搜索（Linear Search），也称为顺序搜索，是最基本的搜索算法之一。它的工作原理是通过遍历数组或列表中的每一个元素，直到找到目标值为止，或者遍历完所有元素后确定目标值不存在于列表中。线性搜索的时间复杂度为O(n)，其中n是列表中元素的数量。这是因为最坏情况下，你可能需要检查列表中的每一个元素才能找到目标值或确定它不在列表中。
【数据结构】详解堆
老师我想进步
07-16 863
升序：建大堆降序：建小堆（1）升序：建大堆【思考】排升序，建小堆可以吗？-- 可以（但不推荐）。首先对 n 个数建小堆，选出最小的数，接着对剩下的 n-1 个数建小堆，选出第二小的数，不断重复上述过程。【时间复杂度】建 n 个数的堆时间复杂度是 O(N)，所以上述操作时间复杂度为 O(N²)，效率太低，关系变得杂乱，尤其是当数据量大的时候，效率就更低。同时堆的价值也没有被体现出来，这样不如用直接排序。排升序，因为数字依次递增，需要找到最大的数字，得建大堆。首先对 n 个数建大堆。
数据结构之细说链表
最新发布
m0_73634434的博客
07-17 757
这里while循环的条件判断必须是tail->next->next，因为我们需要释放最后一个节点的地址，所以需要利用它前面一共节点来释放它，然后将tail->next置空，如果我们直接找最后一个地址然后将它释放前面一个节点就会指向被释放的地址变成一个野指针，因为我们已经找不到前面一个节点的位置了。头插就比较简单了，将该节点连接在第一个节点和第二个节点之间就可以了，但是我们需要先连接第二个和新节点，如果先连接第一个节点和新节点就会找不到第二个节点的地址。下面我们给出链表的构成，看看链表是如何解决这些问题的。
数据结构(4.4)——求next数组
m0_65240792的博客
07-14 366
next[1]都无脑写0next[2]都无脑写1其他next:在不匹配的位置前边，划一条分界线，模式串一步一步往后退，直到分界线之前"能对上"，或模式串能完全跨过分界线为止，此时j指向哪儿，next数组值就是多少ababaa的next数组//求next[1]??????->??????/i=1->i=2ababaa-> ababaa //j=0,第一个字符匹配失败，只能匹配下一个子串，++i，++jnext[1]=0;//求next[2]a?????->a??????//i=2。
【数据结构】--- 堆的应用
分享记录学习的过程！
07-12 665
​。
创建空数据结构：列表、元组、字典和集合
2202_75569688的博客
07-17 149
在 Python 编程中，数据结构是存储和管理数据的基本单元。常用的数据结构包括列表、元组、字典和集合。在实际编程中，时常需要初始化这些数据结构为空。本文将详细介绍如何创建空列表、空元组、空字典和空集合。
数据结构C语言：二叉排序树与结点定义
在给定的描述中，定义了一个名为`BSTNode`的二叉搜索树（Binary Search Tree, BST）节点。这个结构体包含三个成员：`KeyType key`代表关键字域，用于存储数据；`...`表示可能存在其他数据域；`struct Node *Lchild, ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值