二叉搜索树的插入、查找、查找最大值、删除

最新推荐文章于 2024-10-15 19:28:18 发布
最新推荐文章于 2024-10-15 19:28:18 发布
阅读量447 收藏 1
点赞数 3
文章标签： 算法 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l_tian_tian_/article/details/137168476
版权
本文详细介绍了如何在二叉搜索树中使用递归实现插入、查找、查找最大值以及删除操作。通过一系列示例展示了如何处理不同情况下的节点替换和结构调整。
摘要由CSDN通过智能技术生成

插入代码(递归)

BTNode* BTInsert(BTNode* root, BTDataType a)
{
	if (root == NULL)
	{
		BTNode*newnode=(BTNode*)malloc(sizeof(BTNode));
		assert(newnode);
		newnode->Data = a;
		newnode->left = NULL;
		newnode->right = NULL;
		return newnode;
	}
	else if (a < root->Data)
	{
		root->left = BTInsert(root->left, a);
	}
	else
	{
		root->right  = BTInsert(root->right , a);
	}
	return root;
}

我们可以通过假设只在根节点root插入数据（3种情况）

1.root为空

2.插入值小于root的值

3.插入值大于root的值

我们可以使用递归，从而完成插入。

查找代码（递归）

BTNode* BTSearch(BTNode* root, BTDataType a)
{
	if (root == NULL || root->Data == a)
	{
		return root;
	}
	else if (a < root->Data)
	{
		return BTSearch(root->left, a);
	}
	else
	{
		return BTSearch(root->right, a);
	}

}

我们可以通过假设只在根节点root插入数据（3种情况）

1.root为空或root的值等于要查找的值

2.查找的值小于root的值

3.查找的值大于root的值

我们可以使用递归，从而完成查找。

查找最大值

BTNode* BTFindMax(BTNode* root)
{
    assert(root);
	if (root->right == NULL)
	{
		return root;
	}
	else
	{
		while (root->right)
		{
			root = root->right;
		}
		return root;
	}
}

根据搜索二叉树的性质最大值一定在搜索二叉树的最右端,因此我们可以沿着根结点不断往下找，直到找到右结点为空。

删除

删除分为4种情况

1.要删除的结点左右孩子都为空

直接删除

2.要删除的结点左孩子为空，右孩子不为空

（1）.判断要删除的结点在父节点的左孩子还是右孩子

（2）.将要删除的结点右孩子连接到父节点

（3）.释放结点

3.要删除的结点左孩子不为空，右孩子为空

（1）.判断要删除的结点在父节点的左孩子还是右孩子

（2）.将要删除的结点左孩子连接到父节点

（3）.释放结点

4.要删除的结点左右孩子都不为空（找到要删除结点左孩子为根的最大值）

1.找到要删除结点左孩子为根的最大值的结点为swap

2.找到swap的父节点

3.将要删除的结点的值替换为swap的值

4.删除结点swap

void BTDelete(BTNode* root, BTDataType a)
{
	assert(root);
	BTNode* aim = BTSearch(root, a);//aim为删除对象
	if (aim == NULL)
	{
		printf("不存在此数，删除失败\n");
		exit(-1);
	}
	BTNode* aimleft = aim->left;
	BTNode* aimright = aim->right;
	BTNode* parent = NULL;
	//左右孩子都为空
	if (aimleft == NULL && aimright == NULL)
	{
		parent = BTChildParent(root, a);
		if (a < parent->Data)
		{
			parent->left = NULL;
		}
		else
		{
			parent->right = NULL;
		}
		free(aim);
		aim = NULL;
	}
	//只有左孩子节点
	else if (aimleft != NULL && aimright == NULL)
	{
		parent = BTChildParent(root, a);
		if (parent->Data < aim->Data)
		{
			parent->right = aim->left;
		}
		else
		{
			parent->left = aim->left;
		}
		free(aim);
		aim = NULL;
	}

	//只有右孩子
	else if (aimleft == NULL && aimright != NULL)
	{
		parent = BTChildParent(root, a);
		if (parent->Data < aim->Data)
		{
			parent->right = aim->right;
		}
		else
		{
			parent->left = aim->right;
		}
		free(aim);
		aim = NULL;
	}

	//既有左孩子又有右孩子
	else
	{
		BTNode* swap = BTFindMax(aim->left);//swap用于aim赋值
		parent = BTChildParent(root, swap->Data);//parent为swap的父亲
		aim->Data = swap->Data;
		//swap左右孩子都为空（既有左孩子又有右孩子)
		if (swap->left == NULL && swap->right == NULL)
		{
			if (parent->Data < swap->Data)
			{
				parent->right = NULL;
			}
			else
			{
				parent->left = NULL;
			}
		}


		//swap只有左孩子节点（既有左孩子又有右孩子)
		else if (swap->left != NULL && swap->right == NULL)
		{
			if (parent->Data < swap->Data)
			{
				parent->right = swap->left;
			}
			else
			{
				parent->left = swap->left;
			}
			free(swap);
			swap = NULL;
		}

		//swap只有右孩子节点（既有左孩子又有右孩子)
		else if (swap->left == NULL && swap->right != NULL)
		{
			if (parent->Data < swap->Data)
			{
				parent->right = swap->right;
			}
			else
			{
				parent->left = swap->right;
			}
			free(swap);
			swap = NULL;
		}
	}
}

源代码

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int BTDataType;
typedef struct BinaryTreeNode
{
	BTDataType Data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;

//前序（递归）
void PrevOrder(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}
	printf("%d ", root->Data);
	PrevOrder(root->left);
	PrevOrder(root->right);
}

//中序（递归）
void InOrder(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}
	InOrder(root->left);
	printf("%d ", root->Data);
	InOrder(root->right);
}

//后序（递归）
void PostOrder(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}
	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->Data);
}

//层序（队列）
void LevelOrder(BTNode* root)
{
	assert(root);
	int head = 0;
	int tail = 0;
	BTNode* tem;
	BTNode* BTarr[1000];
	tail++;
	BTarr[tail] = root;
	while (tail != head)
	{
		head++;
		tem = BTarr[head];
		printf("%d ", tem->Data);
		if (tem->left != NULL)
		{
			tail++;
			BTarr[tail] = tem->left;
		}

		if (tem->right != NULL)
		{
			tail++;
			BTarr[tail] = tem->right;
		}

	}
}

//插入（递归）
BTNode* BTInsert(BTNode* root, BTDataType a)
{
	if (root == NULL)
	{
		BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));
		assert(newnode);
		newnode->Data = a;
		newnode->left = NULL;
		newnode->right = NULL;
		return newnode;
	}
	else if (a < root->Data)
	{
		root->left = BTInsert(root->left, a);
	}
	else
	{
		root->right = BTInsert(root->right, a);
	}
	return root;
}

//查找（递归）
BTNode* BTSearch(BTNode* root, BTDataType a)
{
	if (root == NULL || root->Data == a)
	{
		return root;
	}
	else if (a < root->Data)
	{
		return BTSearch(root->left, a);
	}
	else
	{
		return BTSearch(root->right, a);
	}

}

//找双亲
BTNode* BTChildParent(BTNode* root, BTDataType a)
{
	assert(root);
	if (root->right)
	{
		if (root->right->Data == a)
		{
			return root;
		}
	}
	if (root->left)
	{
		if (root->left->Data == a)
		{
			return root;
		}
	}

	if (a < root->Data)
	{
		return BTChildParent(root->left, a);
	}
	else
	{
		return BTChildParent(root->right, a);
	}
}

//找最搜索二叉树的最大值并返回地址
BTNode* BTFindMax(BTNode* root)
{
	assert(root);
	if (root->right == NULL)
	{
		return root;
	}
	else
	{
		while (root->right)
		{
			root = root->right;
		}
		return root;
	}

}

void BTDelete(BTNode* root, BTDataType a)
{
	assert(root);
	BTNode* aim = BTSearch(root, a);//aim为删除对象
	if (aim == NULL)
	{
		printf("不存在此数，删除失败\n");
		exit(-1);
	}
	BTNode* aimleft = aim->left;
	BTNode* aimright = aim->right;
	BTNode* parent = NULL;
	//左右孩子都为空
	if (aimleft == NULL && aimright == NULL)
	{
		parent = BTChildParent(root, a);
		if (a < parent->Data)
		{
			parent->left = NULL;
		}
		else
		{
			parent->right = NULL;
		}
		free(aim);
		aim = NULL;
	}
	//只有左孩子节点
	else if (aimleft != NULL && aimright == NULL)
	{
		parent = BTChildParent(root, a);
		if (parent->Data < aim->Data)
		{
			parent->right = aim->left;
		}
		else
		{
			parent->left = aim->left;
		}
		free(aim);
		aim = NULL;
	}

	//只有右孩子
	else if (aimleft == NULL && aimright != NULL)
	{
		parent = BTChildParent(root, a);
		if (parent->Data < aim->Data)
		{
			parent->right = aim->right;
		}
		else
		{
			parent->left = aim->right;
		}
		free(aim);
		aim = NULL;
	}

	//既有左孩子又有右孩子
	else
	{
		BTNode* swap = BTFindMax(aim->left);//swap用于aim赋值
		parent = BTChildParent(root, swap->Data);//parent为swap的父亲
		aim->Data = swap->Data;
		//swap左右孩子都为空（既有左孩子又有右孩子)
		if (swap->left == NULL && swap->right == NULL)
		{
			if (parent->Data < swap->Data)
			{
				parent->right = NULL;
			}
			else
			{
				parent->left = NULL;
			}
		}


		//swap只有左孩子节点（既有左孩子又有右孩子)
		else if (swap->left != NULL && swap->right == NULL)
		{
			if (parent->Data < swap->Data)
			{
				parent->right = swap->left;
			}
			else
			{
				parent->left = swap->left;
			}
			free(swap);
			swap = NULL;
		}

		//swap只有右孩子节点（既有左孩子又有右孩子)
		else if (swap->left == NULL && swap->right != NULL)
		{
			if (parent->Data < swap->Data)
			{
				parent->right = swap->right;
			}
			else
			{
				parent->left = swap->right;
			}
			free(swap);
			swap = NULL;
		}
	}
}

int main()
{
	BTNode* root = NULL;
	root = BTInsert(root, 25);
	root = BTInsert(root, 20);
	root = BTInsert(root, 36);
	root = BTInsert(root, 10);
	root = BTInsert(root, 22);
	root = BTInsert(root, 30);
	root = BTInsert(root, 40);
	root = BTInsert(root, 5);
	root = BTInsert(root, 12);
	root = BTInsert(root, 28);
	root = BTInsert(root, 38);
	root = BTInsert(root, 48);
	root = BTInsert(root, 1);
	root = BTInsert(root, 8);
	root = BTInsert(root, 15);
	root = BTInsert(root, 45);
	root = BTInsert(root, 50);
	BTDelete(root,25);
	InOrder(root);
	printf("\n");
	LevelOrder(root);
	return 0;

}

搜索二叉树：

运行结果：

l_tian_tian_
关注
二叉搜索树/二叉排序树/二叉查找树
further_的博客
09-01 2165
怕
Java 实现二叉搜索树的查找、插入、删除、遍历
08-31
以下是Java实现二叉搜索树的查找、插入、删除和遍历的关键点： 1. **查找节点**： - 查找操作基于二叉搜索树的性质，从根节点开始，如果目标键值小于当前节点的键值，就向左子树移动；如果目标键值大于当前节点的...
二叉搜索树（查找、插入、删除的讲解实现+图文并茂）
bang___bang_的博客
05-25 8847
本文讲解并模拟实现二叉搜索树，详解它的查找、插入、删除及实现，并对二叉搜索树的应用场景进行描述，最后进行了性能分析！
二叉排序树（二叉查找树、二叉搜索树）（图解+完整代码）
热门推荐
weixin_54186646的博客
04-25 8万+
图解二叉排序树（二叉查找树、二叉搜索树）的插入操作、查找操作、删除操作以及完整的代码实现
二叉搜索树:查找,插入,删除操作
NIHANA_HR的博客
05-15 1054
什么是二叉搜索树 二叉搜索树是由二叉树组织的,如下:和普通二叉树相比多了parent结点,这样可以匹配搜索二叉树性质方便实现相应的功能;二叉搜索树有那些性质呢: 对任何结点x,其左子树中的关键字最大不超过x.key,其右子树中的关键字最小不低于x.key. class Node { public: int key; node*left; node*right; node*parent; }; 我们可以使用中序遍历方法遍历这颗树,这样结果就是有序的 上图所示搜索二叉树中序遍历结果为:1
二叉搜索树——插入、查找、删除
weixin_45728685的博客
03-26 811
二叉搜索树 二叉搜索树的特点 根节点的值大于左结点的值，小于右结点的值 根节点的左、右子树也是一个二叉搜索树 没有重复值 中序遍历得到的序列是从小到大排列的 二叉树的存储结构 typedef struct tree { int data; struct tree *leftchild; struct tree *rightchild; } BiNod...
二叉搜索树（树表查找）
qq_55078860的博客
08-14 780
32>30，从32结点的左子树查找，左子树为空，查找不成功，创建一个新的结点插入为32结点的左节点。二叉查找树删除的特殊情况：p==q，p的左子树的右节点为空，即p的左节点就是p的直接前驱s（左子树的最右结点，不用到最右结点了），那么删除s时，q的左孩子是s的左孩子。第二层：2（1，3）、6（5，7）、 10（9，11）、14（13，15）【num（num-2^1+1，num+2^1-1）】①若二叉查找树为空，创建一个新的结点s，将待插入关键字放入新结点的数据域，s结点作为根结点，左右子树均为空；
二叉排序树的查找插入删除等操作
sofanfanfan的博客
11-16 3155
二叉排序树的各种操作，数据结构与算法设计实验
二叉排序树插入，查找，删除操作
Powerking666的博客
07-18 2203
二叉排序树 二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树 性质：左子树<根<右子树。（比较的是值）。 中序遍历结果是有序的。 示例图 （图来自小甲鱼学习视频） 插入操作 1：若二叉树为空，首先单独生成根节点。 2：插入值与根值比较，若前者小插入到左子树当中。若前者大，插入到右子树当中。 代码： void insert(BiTree* tree, int value)//创建树 { BiTNode* node=(B
二叉查找树（BST）｜搜索及插入操作
嗅探网的博客
08-30 720
假设我们要搜索数字，我们从根开始，然后我们将要搜索的值与根的值进行比较，如果相等，我们完成搜索，如果它更小，我们知道我们需要转到左子树，因为在二叉查找树中，左子树中的所有元素都较小，而右子树中的所有元素都较大。为了搜索一个值，如果我们有一个排序数组，我们可以通过二分查找法来进行搜索。在二分查找中，我们从搜索空间中的“n”个元素开始，如果中间元素不是我们正在寻找的元素，我们将搜索空间减少到“n/2”，以此类推我们不断缩小搜索空间，直到我们找到想要寻找的值，或者我们将搜索空间缩小到一个元素并停止搜索。.....
详解二叉搜索树的查找、插入、删除操作（数据结构）
m0_51405559的博客
11-26 2183
文章目录一、概念二、操作——查找三、操作——插入四、操作——删除（难点） 一、概念 二叉搜索树又称二叉排序树，它可能是一棵空树，也可能是具有以下性质的二叉树： 1.若它的左子树不为空，则左子树上所有结点的值都小于根结点的值 2.若他的右子树不为空，则右子树上所有结点的值都大于根结点的值 3.它的左右子树也分别为二叉搜索树 例如下图： 二、操作——查找 步骤： 1.假如根结点不为空： 如果根结点.key==查找.key，返回true 如果根结点.key>查找.key，在其左子树中查找 ..
c代码-查找二叉搜索树的最大和最小元素
07-14
在IT领域，二叉搜索树（Binary...总结来说，这个项目涉及了C语言基础、二叉搜索树的概念、节点结构体的定义以及查找BST中最大和最小元素的算法。理解这些知识点对于学习数据结构和算法以及进行实际的编程项目非常重要。
二叉搜索树的插入与删除(详细解析)
09-05
这种特性使得二叉搜索树在查找、插入和删除操作上具有较高的效率。 **插入节点** 插入节点的过程相对简单。首先，我们需要创建一个新的节点，并为其分配值。然后，从根节点开始，根据新节点的值与当前节点的值进行...
二叉查找树的插入,删除,查找
09-05
递归方法`insert()`会根据节点值与当前节点值的比较，选择向左子树还是右子树插入。非递归方法`insert_BST()`使用循环来遍历树，直到找到合适的位置插入新节点。 **二叉查找树的删除操作** 删除节点时，我们需要...
34. 在排序数组中查找元素的第一个和最后一个位置
weixin_61695887的博客
10-12 490
请你找出给定目标值在数组中的开始位置和结束位置。给你一个按照非递减顺序排列的整数数组。你必须设计并实现时间复杂度为。如果数组中不存在目标值。
图算法之Floyd-Warshall 算法（全点对最短路径）详细解读
m0_61840987的博客
10-11 793
Floyd-Warshall 算法是求解全点对最短路径的经典算法，适用于需要处理负权边的场景。它的时间复杂度较高，因此适合处理顶点较少的密集图，而不是稀疏图。如果图中存在负权环，该算法可以用来检测。
【从零开始的LeetCode-算法】3099. 哈沙德数
最新发布
qq_40878316的博客
10-15 124
如果一个整数能够被其各个数位上的数字之和整除，则称之为。各个数位上的数字之和，否则，返回。各个数位上的数字之和为。各个数位上的数字之和为。不是哈沙德数，答案是。
力扣10.13
qq_40052678的博客
10-13 349
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
【优选算法】（第四十二篇）
weixin_73861555的博客
10-15 768
输⼊：beginWord="hit",endWord="cog",wordList=["hot","dot","dog","lot","log","cog"]输出：5。输⼊：beginWord="hit",endWord="cog",wordList=["hot","dot","dog","lot","log"]输出：0。解释：⼀个最短转换序列是"hit"->"hot"->"dot"->"dog"->"cog",返回它的⻓度5。解释：endWord"cog"不在字典中，所以⽆法进⾏转换。
C二叉搜索树删除节点
06-03
C语言中的二叉搜索树是一种非常常用的数据结构，其插入和查找的时间复杂度都是O(logn)。当然，在使用二叉搜索树时，我们也需要注意它的删除操作，否则会影响它的性能。 二叉搜索树的删除操作可以分为以下三种情况： 1. 被删除节点为叶子节点：直接将其删除即可。 2. 被删除节点只有一个子节点：将其子节点替代被删除节点即可。 3. 被删除节点有两个子节点：需要找到其右子树中的最小值或左子树中的最大值来替代被删除节点。 具体实现时，我们可以使用递归或者迭代的方式进行实现。下面是一个使用递归的实现方式： ``` struct TreeNode* deleteNode(struct TreeNode* root, int key) { if (root == NULL) return root; if (key < root->val) { root->left = deleteNode(root->left, key); } else if (key > root->val) { root->right = deleteNode(root->right, key); } else { if (root->left == NULL) { struct TreeNode* temp = root->right; free(root); return temp; } else if (root->right == NULL) { struct TreeNode* temp = root->left; free(root); return temp; } else { struct TreeNode* temp = findMin(root->right); root->val = temp->val; root->right = deleteNode(root->right, temp->val); } } return root; } struct TreeNode* findMin(struct TreeNode* node) { while (node->left != NULL) node = node->left; return node; } ``` 以上代码中，deleteNode函数使用递归实现了删除操作，findMin函数则是用来找到右子树中的最小值。在deleteNode函数中，我们首先判断了要删除的节点是否为空，然后再根据二叉搜索树的性质来判断要删除的节点在左子树还是右子树中。如果要删除的节点为叶子节点或只有一个子节点，则直接将其替换即可；如果要删除的节点有两个子节点，则需要找到右子树中的最小值（或左子树中的最大值），将其赋值给被删除节点，并在右子树中删除该最小值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值