数表查找之二叉搜索树

最新推荐文章于 2022-12-25 11:04:42 发布
最新推荐文章于 2022-12-25 11:04:42 发布
阅读量817 收藏 1
点赞数 1
分类专栏： 算法 数据结构 文章标签： 数据结构 b树 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46359697/article/details/122131405
版权

文章目录


二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的 二叉树： 二叉搜索树作为一种经典的数据结构，它既有链表的快速插入与删除操作的特点，又有数组快速查找的优势,所以应用十分广泛，例如在文件系统和数据库系统一般会采用这种数据结构进行高效率的排序与检索操作。

1.基本思想

  • 若任意结点的左子树不空，则左子树上所有结点的值均小于它的根结点的值
  • 若任意结点的右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值
  • 任意结点的左、右子树也分别为二叉查找树

满足如上条件二叉树示意图:

既然搜索二叉树满足这样一个特性，如果遍历的时候遵循中序遍历方式，那么打印出来的数据是从小达到排列的！

2.算法步骤

3.代码实现

struct BSTnode
{
	int data;
	struct BSTnode* lchild;
	struct BSTnode* rchild;
};

二叉搜索树每一个节点的物理存储结构！

3.2.算法实现

3.3.1.创建

二叉搜索树创建的实现是很简单的,就是初始化树的根节点.

struct BSTnode* root;//创建根节点

root = NULL;//默认root为NULL

创建好根节点之后记得赋值为0.

3.3.2.查找
int binaryTreeSearch(struct BSTnode* root, int data)
{
	if (root == NULL)
		return 0; //return 0 
	else
	{
		if (root->data == data)
			return 1;
		else
		{
			if (root->data < data)
				return binaryTreeSearch(root->rchild, data);
			else
				return binaryTreeSearch(root->lchild, data);
		}
	}
}
3.3.3.插入
struct BSTnode* binaryTreeInsert(struct BSTnode* root, int data)//插入二叉搜索树的节点 
{
	if (root == NULL)//找到直接返回
	{
		struct BSTnode* s;
		//构造要插入的节点
		s = (struct BSTnode*)malloc(sizeof(struct BSTnode));
		s->data = data;
		s->lchild = NULL;
		s->rchild = NULL;
		root = s;
		return root;
	}
	else
	{
		if (data > root->data) 
			root->rchild = binaryTreeInsert(root->rchild,data);//回朔的时候将父节点与本节点联系起来
		else
			root->lchild = binaryTreeInsert(root->lchild,data);//回朔的时候将父节点与本节点联系起来
	}
	return root;//回溯的时候有用
}
3.2.4.迭代

大家需要注意，迭代的方式一定要是中序遍历，因为这个是由二叉搜索树的性质决定的。如果以中序遍历的方式遍历的话，那么遍历打印出来的数据是从小到大排列的。如果出现不满足升序的情况，那么就意味着二叉搜索树的排列是正确的！

void binaryTreeIteration(struct BSTnode* root)//中序遍历
{
	if (root == NULL)
		return;
	binaryTreeIteration(root->lchild);
	printf("%d   ", root->data);
	binaryTreeIteration(root->rchild);
}
3.2.5.删除
struct BSTnode* BinaryTreeInsertBp(struct BSTnode* root, struct BSTnode* child)//插入二叉搜索树的节点 
{
	if (child == NULL)//child为NULL意味着该处没有节点
	{
		return;
	}
	if (root == NULL)//找到直接返回
	{	
		root = child;
		return root;
	}
	else
	{
		if (child->data>root->data)
			root->rchild = BinaryTreeInsertBp(root->rchild, child);//回朔的时候将父节点与本节点联系起来
		else
			root->lchild = BinaryTreeInsertBp(root->lchild, child);//回朔的时候将父节点与本节点联系起来
	}
	return root;
}
struct BSTnode* binaryTreeDelete(struct BSTnode** rootParent, int data)
{
	static struct BSTnode* Parent;
	static struct BSTnode* child;
	struct BSTnode* root = *rootParent;
	if (root == NULL)
		return 0; // 终止条件，没找到待删除的元素，不进行任何操作！
	else 
	{
		if (root->data == data)//已经找到了数据,将相应的节点删除
		{
			if (Parent == NULL)//这就意味着要删除的是根节点， 
			{
				printf("祖宗都敢删？吃了什么熊心豹子胆\n");
				Parent = root->rchild;
				if (Parent == NULL)
					Parent = root->lchild;
				else
					BinaryTreeInsertBp(root->rchild, root->lchild);//如果你连祖宗都不放在眼里，那就uncomment
				free(root);//一定要注意，free只是把root所指向的内存块给回收了，并不意味着root的值为0了
				*rootParent= Parent;//这个时候要用Parent更新root的值
				Parent = NULL;
				return 1;
			}
			else//这意味着要删除的不是根节点
			{
				if (Parent->lchild == child)//1.检查child是parent的左孩子还是右孩子
				{
					Parent->lchild = child->rchild;
					if (Parent->lchild == NULL)
						Parent->lchild = child->lchild;
					else
						BinaryTreeInsertBp(Parent->lchild, child->lchild);
				}
				else
				{
					Parent->rchild = child->rchild;
					if (Parent->rchild == NULL)
						Parent->rchild = child->lchild;
					else
						BinaryTreeInsertBp(Parent->rchild, child->lchild);
				}
				free(child);//删除节点
				//记得更新节点，清除标志
				Parent = NULL;
				child = NULL;
				return 1;
			}
		}
		else //还没有找到
		{
			Parent = root;
			if (root->data < data)
			{
				child = root->rchild;
				return binaryTreeDelete(&(root->rchild), data);
			}	
			else
			{
				child = root->lchild;
				return binaryTreeDelete(&(root->lchild), data);
			}
		}
	}
}

3.2.测试程序

void main()
{
	struct BSTnode* root;//创建根节点
	int data, i;
	int tree[] = {23,12,3,10,9,7,15,16,20,18,13,5,8,22,26,34,15,67,89,42,62,14,53};//创建树
	root = NULL;//默认root为NULL
	//构建搜索二叉树
	for (i = 0; i < sizeof(tree)/sizeof(*tree); i++)
	{
		root = binaryTreeInsert(root, tree[i]);
		//printf("第%d次\n",i + 1);
		//tree_scaner(root);//遍历二叉搜索树 
		//printf("\n");
	}
	binaryTreeIteration(root);//遍历二叉搜索树 
	//在二叉搜索树种查找某个节点，并删除某个节点
	while (1)
	{
		printf("\ninput key:");
		scanf("%d", &data);
		if (binaryTreeSearch(root, data))
		{
			printf("yes\n");
		}
		else
		{
			printf("failed\n");
		}
		printf("delete key:");
		scanf("%d", &data);
		binaryTreeDelete(&root, data);//注意，这里传递的参数是root的地址值
		binaryTreeIteration(root);
	}
	system("pause");
}

4.实验结果与心得

在二叉搜索树的算法实现中，最重要也是最难的就是元素的删除。大家一定要多花点时间看看，这个看懂可能对提升你的代码能力有很大的帮助

本算法中有一个缺点，就是在删除的时候，如果待删除的元素不在搜索树中，不会进行相应的提示，直接忽略。但这不重要，你关注的应该是算法的设计思想！

从上面的图中，我们可以发现，数据元素是升序排列的，这是因为我选择的遍历算法是中序遍历算法。因为使用这种遍历算法能够在命令行的状态下进行看出该二叉树的分布是不是正确的（如果不是升序那就意味着树中某些部分不满足二叉搜索树的定义）

而且二叉搜索树既有数组的优点又有链表的优点.因此二叉树广泛的运用在数据库等对数据查找要求较高的领域。

完整代码

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
struct BSTnode
{
	int data;
	struct BSTnode* lchild;
	struct BSTnode* rchild;
};
struct BSTnode* binaryTreeInsert(struct BSTnode* root, int data)//插入二叉搜索树的节点 
{
	if (root == NULL)//找到直接返回
	{
		struct BSTnode* s;
		//构造要插入的节点
		s = (struct BSTnode*)malloc(sizeof(struct BSTnode));
		s->data = data;
		s->lchild = NULL;
		s->rchild = NULL;
		root = s;
		return root;
	}
	else
	{
		if (data > root->data) 
			root->rchild = binaryTreeInsert(root->rchild,data);//回朔的时候将父节点与本节点联系起来
		else
			root->lchild = binaryTreeInsert(root->lchild,data);
	}
	return root;
}
void binaryTreeIteration(struct BSTnode* root)//中序遍历
{
	if (root == NULL)
		return;
	binaryTreeIteration(root->lchild);
	printf("%d   ", root->data);
	binaryTreeIteration(root->rchild);
}
int binaryTreeSearch(struct BSTnode* root, int data)
{
	if (root == NULL)
		return 0; //return -1程序出错，if语句认为-1不是FALSE。而0是FALSE。 
	else
	{
		if (root->data == data)
			return 1;
		else
		{
			if (root->data < data)
				return binaryTreeSearch(root->rchild, data);
			else
				return binaryTreeSearch(root->lchild, data);
		}
	}
}
struct BSTnode* BinaryTreeInsertBp(struct BSTnode* root, struct BSTnode* child)//插入二叉搜索树的节点 
{
	if (child == NULL)//child为NULL意味着该处没有节点
	{
		return;
	}
	if (root == NULL)//找到直接返回
	{	
		root = child;
		return root;
	}
	else
	{
		if (child->data>root->data)
			root->rchild = BinaryTreeInsertBp(root->rchild, child);//回朔的时候将父节点与本节点联系起来
		else
			root->lchild = BinaryTreeInsertBp(root->lchild, child);//回朔的时候将父节点与本节点联系起来
	}
	return root;
}
struct BSTnode* binaryTreeDelete(struct BSTnode** rootParent, int data)
{
	static struct BSTnode* Parent;
	static struct BSTnode* child;
	struct BSTnode* root = *rootParent;
	if (root == NULL)
		return 0; // 终止条件，表示没有找到带查找的数据
	else 
	{
		if (root->data == data)//已经找到了数据,将相应的节点删除
		{
			if (Parent == NULL)//这就意味着要删除的是根节点， 
			{
				printf("祖宗都敢删？吃了什么熊心豹子胆\n");
				Parent = root->rchild;
				if (Parent == NULL)
					Parent = root->lchild;
				else
					BinaryTreeInsertBp(root->rchild, root->lchild);//如果你连祖宗都不放在眼里，那就uncomment
				free(root);//一定要注意，free只是把root所指向的内存块给回收了，并不意味着root的值为0了
				*rootParent= Parent;//这个时候要用Parent更新root的值
				Parent = NULL;
				return 1;
			}
			else//这意味着要删除的不是根节点
			{
				if (Parent->lchild == child)//1.检查child是parent的左孩子还是右孩子
				{
					Parent->lchild = child->rchild;
					if (Parent->lchild == NULL)
						Parent->lchild = child->lchild;
					else
						BinaryTreeInsertBp(Parent->lchild, child->lchild);
				}
				else
				{
					Parent->rchild = child->rchild;
					if (Parent->rchild == NULL)
						Parent->rchild = child->lchild;
					else
						BinaryTreeInsertBp(Parent->rchild, child->lchild);
				}
				free(child);//删除节点
				//记得更新节点，清除标志
				Parent = NULL;
				child = NULL;
				return 1;
			}
		}
		else //还没有找到
		{
			Parent = root;
			if (root->data < data)
			{
				child = root->rchild;
				return binaryTreeDelete(&(root->rchild), data);
			}	
			else
			{
				child = root->lchild;
				return binaryTreeDelete(&(root->lchild), data);
			}
		}
	}
}
void main()
{
	struct BSTnode* root;//创建根节点
	int data, i;
	int tree[] = {23,12,3,10,9,7,15,16,20,18,13,5,8,22,26,34,15,67,89,42,62,14,53};//创建树
	root = NULL;//默认root为NULL
	//构建搜索2叉树
	for (i = 0; i < sizeof(tree)/sizeof(*tree); i++)
	{
		root = binaryTreeInsert(root, tree[i]);
		//printf("第%d次\n",i + 1);
		//tree_scaner(root);//遍历二叉搜索树 
		//printf("\n");
	}
	binaryTreeIteration(root);//遍历二叉搜索树 
	//在二叉搜索树种查找某个节点
	while (1)
	{
		printf("\ninput key:");
		scanf("%d", &data);
		if (binaryTreeSearch(root, data))
		{
			printf("yes\n");
		}
		else
		{
			printf("failed\n");
		}
		printf("delete key:");
		scanf("%d", &data);
		binaryTreeDelete(&root, data);
		binaryTreeIteration(root);
	}
	system("pause");
}
嵌入式定制设计工坊
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数表的查找
Qsq_Zpy的博客
05-08 391
一、顺序查找（Sequential Search） 顺序查找（Sequential Search）又叫线性查找，是最基本的查找技术。 顺序查找的过程：从表中第一个（ 或最后一个）开始，逐个记录的关键字和给定值比较，若某个记录的关键字和给定值相等，则查找成功，找到所查的记录；如果知道最后一个（或第一个）记录，其关键字和给定值比较都不等时，则表中没有所查的记录，查找不成功。 代码实现： /** * 顺序查找 * @param arr 数组 * @param key 要查找的数 *...
数据结构——树表的查找（二叉排序树）
Labrador_Katie的博客
02-22 962
数据结构——树表的查找树表的查找二叉排序树（Binary Sort Tree）二叉排序树的操作——查找二叉排序树的存储结构二叉排序树的查找分析二叉排序树的插入二叉排序树的生成二叉排序树的删除 树表的查找   当表插入、删除操作频繁时，为维护表的有序性，需要移动表中很多记录。   改用动态查找表——几种特殊的树       二叉排序树（Binary Sort Tree） 二叉排序树（Binary Sort Tree）又称为二叉搜索树、二叉查找树， 定义： 二叉排序树或是空树，或是满足如下性质的二叉树：   
算法2.4.24：查找链表二叉树节点
mikefbi的博客
03-28 622
算法第四版习题2.4.24： 用堆有序的二叉树实现一个优先队列，但使用链表结构，每个结点需要三个链接：两个向下，一个向上。要求算法基本操作所需时间为对数级。 二叉树如图： 此算法实现的主要步骤： 1.将新元素插入到最末结点之后，并上浮到合适位置 2. 从二叉树顶端删除最大元素，并将最末结点放到顶端，并下沉顶结点。 此算法的难点在于如何定位最末结点向后一位的结点 沈星繁博客中提出的解决办法是：维护...
查找二叉树-链表实现
Mind Code
09-25 597
对于查找二叉树，一般用来进行cha
查找表的算法//四数之和
11-06 146
给定一个包含n个整数的数组nums和一个目标值target，判断nums中是否存在四个元素a，b，c和d，使得a+b+c+d的值与target相等？找出所有满足条件且不重复的四元组。 注意： 答案中不可以包含重复的四元组。 示例： 给定数组 nums = [1, 0, -1, 0, -2, 2]，和 ta...
二叉搜索树实例练习
09-05
这种结构使得二叉搜索树非常适合于查找、插入和删除等操作。在中序遍历二叉搜索树时，节点将按照升序（默认）顺序访问，这也是它被称为“排序树”的原因。 在给定的实例练习中，我们看到一个具体的问题：判断两个...
面试题36. 二叉搜索树与双向链表
12-21
二叉搜索树是一种特殊的二叉树，其每个节点的值都大于其左子树中所有节点的值，并小于其右子树中所有节点的值。本题要求将一个二叉搜索树转换为一个排序的循环双向链表。在这个过程中，不能创建新的节点，只能调整树...
Python实现二叉搜索树BST的方法示例
09-18
二叉搜索树（BST，Binary Search Tree），又称为二叉查找树或二叉排序树，是一种特殊的二叉树数据结构，其每个节点的值满足以下条件： 1. 节点的左子树中所有节点的值都小于该节点的值。 2. 节点的右子树中所有节点...
树-98. 验证二叉搜索树-PYTHON
01-20
在二叉搜索树（Binary Search Tree，BST）中，每个节点的值必须满足以下规则：对于任意节点，其左子树中的所有节点的值都小于该节点的值，而其右子树中的所有节点的值都大于该节点的值。在给定的题目“树-98. 验证...
二叉搜索树_二叉搜索树_源码
10-04
这种特性使得二叉搜索树非常适合进行查找、插入和删除操作，因为这些操作的时间复杂度可以达到O(log n)。 在给定的“二叉搜索树_二叉搜索树_源码”压缩包中，包含了一个名为“二叉搜索树.c”的源代码文件和一个编译...
【数据结构】查找番外篇 静态数表的查找 次优查找树
Bill_Utada的成长之路
02-13 1420
二分查找对于等概率的查找的性能是最优的，但是如果我们对于数据查找的概率不相等时，显而易见简单再用二分查找不一定能得到最高的效率。 如果只考虑查找成功的情况，则使查找性能达最佳的判定树是其带权内路径长度之和PH值(PH=w1h1+w2h2+...+wnhn)取最小值的二叉树。 这种二叉树称为静态最优查找树。 找到最优查找树的方法复杂度较高，讨论构造一个PH值"近似最小"的次优查
数据结构_查找_静态查找数表_构造次优查找树
Dreamer Thinker Doer
10-27 2929
"SecondOptimal.h" #include using namespace std; #define MAX_DATA_NUM 20//最大节点值 typedef struct SSTable//静态查找表存储结构 { char name; int weight; }ElemType; typedef struct BiTreeNode//二叉链表存储结构 {
二叉搜索树（城市数据库）
weixin_46327567的博客
02-13 5106
实验内容： 1.利用BST实现一个城市数据库：每个数据库结点包括城市名称和以整数x与y表示的城市坐标，根据城市名称组织该BST； 2.在该数据库上实现按城市名称进行的插入、删除和检索； 3.打印出以指定字母打头的所有城市记录； 4.打印出与指定点的距离在给定值之内的所有城市记录； #include <iostream> #include <string> using namespace std; class BSTNode {//二叉树节点 private: string key;
实现二叉查找树进行数据查找
最新发布
Shenrunchen的博客
12-25 351
查找算法：实现二叉查找树进行数据查找
【数据结构】查找— —树表的查找(二叉排序树、平衡二叉树)
qq_43581971的博客
11-13 559
平衡二叉树的一些小结
数据结构：二叉查找树的实现
H的博客
09-25 284
二叉查找树 二叉树是节点最多只有两个子树的树状结构，这两个子树可以称为左子树和右子树。可是对于普通的二叉树，并没有足够的信息来提示我们左子树和右子树存储的是什么，我们没有办法进行高效的信息查找。为了提高查找效率，我们会把二叉树升级为二叉查找树(Binary Search Tree)。 二叉查找树是符合以下定义的二叉树： 1.节点左子树中全部的节点键值都比该节点要小。 2.节点右子树中全部...
数据结构之查找表
热门推荐
黄庆庆的世界
11-12 1万+
前言 今天学习数据结构看到了一个词-静态查找表，还有与之对应的动态查找表，然后我发现。 啊，这是个啥，好像知道又好像不知道，不就是查找吗，干嘛弄这些专业的说法，回头翻了一下数据结构的书，才发现......。 唉，小小的抱怨一下，不过，我从这两个词联想到了一门基础但是要精通又不简单的学问，就是查找，然后还有前天被面试官问到的一个查找题，题目很简单，如何查找单向链表中倒数第K个数？当然你先遍历一...
【数据结构】动态查找表 — 二叉排序树的概述和算法分析
四季轮换叶，一路招摇胜
10-15 3080
动态查找表指在查找过程同时插入查找表中不存在的数据元素，或者从查找表中删除已经存在的某个数据元素。
链表和二叉搜索树的实现（Java）
weixin_43884418的博客
04-24 313
简单的写了一下链表和二叉树，只实现了部分它们的功能，测试类也写好了，可以直接运行 链表 /* * 结点类 */ class Link { public int element; public Link next; public Link(int element) { this.element = element; } } /* * 链表类 */ public class ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值