011——二叉树 （3）二叉搜索树/二叉排序树BST

已于 2024-11-14 19:13:10 修改
阅读量922 收藏 8
点赞数 24
分类专栏： 数据结构 文章标签： 数据结构 算法
于 2024-11-02 14:38:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/immnature/article/details/143380165
版权

目录

高级搜索树：        

分类：

二叉搜索树：

定义：

性质：

特点：

操作：

插入操作

递归方法插入

非递归方法插入

整体代码

删除操作

整体代码：

高级搜索树：        

用于数据的存储和查找的树

分类：

BST        AVL        红黑树        B树        B+树

二叉搜索树：

定义：

在二叉树的基础上增加一些规则：                

                1.如果某节点的左子树不空 ，左子树上所有的节点的值都要小于该节点的值
                2.如果某节点的右子树不空，右子树上所有的节点的值都要大于该节点的值
                3.所有节点都要满足以上约束。

性质：

中序遍历序列有序（从小到大，由规则可知）注意：如果变成从大到小，也是二叉排序树

特点：

优点：提高查找效率（如果是完全二叉树，高度为log2(n+1)向下取整）

缺点：如果用于建树的初始序列有序，建立的BST是一个斜树，高度为n

操作：

插入操作

在空树插入数据x时，将数据k作为根节点即可，左右指针为空

//二叉链表存树
typedef struct BSTnode {
	int data;
	struct BSTnode* left;
	struct BSTnode* right;
}BSTNode, * BSTree;
BSTree initBST(int k)
{
	BSTree r = (BSTNode*)malloc(sizeof(BSTNode));
	//if(r==NULL)
	r->data = k;
	r->left = r->right = NULL;
	return r;
}
递归方法插入

在非空树上插入数据时，假设此时树的根节点是r，判断插入数据k和根节点数据的大小关系：

如果k<r，k插入左子树中，再以r的左孩子作为根节点，让k与其比较，直到找到空结点

如果k>r，k插入右子树中，再以r的右孩子作为根节点，让k与其比较，直到找到空结点

递归出口：结点位置为空

代码：

BSTree insert(BSTree r, int k)
{
	if (r == NULL)
	{
		BSTree s = (BSTNode*)malloc(sizeof(BSTNode));
		//if(s==NULL)
		s->data = k;
		s->left = s->right = NULL;
		return s;
	}
	if (k < r->data)
	{
		r->left = insert(r->left, k);
	}
	if (k > r->data)
	{
		r->right = insert(r->right, k);
	}
	return r;
}
非递归方法插入

在上面的递归方法中，插入位置是在递归的过程中找到的，而在非递归方法中，要是想要插入数据，就需要我们先找到要插入的位置，将给位置的空结点换成要插入的数据结点

查找函数：

void find(BSTree r, int x)
{
	BSTNode* p = r;
	while (p != NULL)
	{
		if (x == p->data)
		{
			cout << "存在" << endl;
			break;
		}
		if (x < p->data)
		{
			p = p->left;
		}
		if (x > p->data)
		{
			p = p->right;
		}
	}
	if (p == NULL)
	{
		cout << "不存在" << endl;
	}
}
BSTree insert_1(BSTree r, int k)
{
	BSTree s = (BSTNode*)malloc(sizeof(BSTNode));
	//if(s==NULL)
	s->data = k;
	s->left = s->right = NULL;
	//空树插入 
	if (r == NULL)
	{
		return s;
	}
	//非空树插入 
	BSTNode* p = r;//遍历
	BSTNode* pre = NULL;//p的父亲
	//遍历找插入位置 
	while (p != NULL)
	{
		if (k < p->data)
		{
			pre = p;
			p = p->left;
		}
		else {
			pre = p;
			p = p->right;
		}
	}
	//插入 
	if (k < pre->data)
	{
		pre->left = s;
	}
	else {
		pre->right = s;
	}
	return r;
}
整体代码
#include <iostream>
using namespace std;
//二叉链表存树
typedef struct BSTnode {
	int data;
	struct BSTnode* left;
	struct BSTnode* right;
}BSTNode, * BSTree;
BSTree initBST(int k)
{
	BSTree r = (BSTNode*)malloc(sizeof(BSTNode));
	//if(r==NULL)
	r->data = k;
	r->left = r->right = NULL;
	return r;
}
BSTree insert(BSTree r, int k)
{
	if (r == NULL)
	{
		BSTree s = (BSTNode*)malloc(sizeof(BSTNode));
		//if(s==NULL)
		s->data = k;
		s->left = s->right = NULL;
		return s;
	}
	if (k < r->data)
	{
		r->left = insert(r->left, k);
	}
	if (k > r->data)
	{
		r->right = insert(r->right, k);
	}
	return r;
}
//-----------非递归-------
BSTree insert_1(BSTree r, int k)
{
	BSTree s = (BSTNode*)malloc(sizeof(BSTNode));
	//if(s==NULL)
	s->data = k;
	s->left = s->right = NULL;
	//空树插入 
	if (r == NULL)
	{
		return s;
	}
	//非空树插入 
	BSTNode* p = r;//遍历
	BSTNode* pre = NULL;//p的父亲
	//遍历找插入位置 
	while (p != NULL)
	{
		if (k < p->data)
		{
			pre = p;
			p = p->left;
		}
		else {
			pre = p;
			p = p->right;
		}
	}
	//插入 
	if (k < pre->data)
	{
		pre->left = s;
	}
	else {
		pre->right = s;
	}
	return r;
}
void inOrder(BSTree r)
{
	if (r == NULL)
	{
		return;
	}
	inOrder(r->left);
	cout << r->data << endl;
	inOrder(r->right);
}
void find(BSTree r, int x)
{
	BSTNode* p = r;
	while (p != NULL)
	{
		if (x == p->data)
		{
			cout << "存在" << endl;
			break;
		}
		if (x < p->data)
		{
			p = p->left;
		}
		if (x > p->data)
		{
			p = p->right;
		}
	}
	if (p == NULL)
	{
		cout << "不存在" << endl;
	}
}
int main()
{
	int n;
	int a[105];
	cin >> n;
	for (int i = 1; i <= n; i++)
	{
		cin >> a[i];

	}
	BSTree r = NULL;
	//-----递归版 不单独初始化根节点------------ 
		 /*
		 for(int i=1;i<=n;i++)
		{
			r=insert(r,a[i]);
		}
		 */
		 //-----递归版 单独初始化根节点------------- 
			  /*
			  r=initBST(a[1]);
			  for(int i=2;i<=n;i++)
			 {
				 r=insert(r,a[i]);
			 }
			 */
			 //------非递归版 ------------------ 
	for (int i = 1; i <= n; i++)
	{
		r = insert_1(r, a[i]);
	}
	//--------------------------- 
	inOrder(r);//中序遍历输出验证 
	cout << endl;
	//查找 
	int x;
	cin >> x;
	find(r, x);

	return 0;
}
/*
9
8 3 10 1 6 14 4 7 13
*/

删除操作

首先要找到要删除的结点p,同时找p的父亲结点pre

在删除的过程，分为三种情况

1）如果p的度为2：在删掉p后，将p的左子树的最靠右的结点m或者是右子树最靠左的结点n移动到删除位置（相当于p的前驱或者是后继），而左子树的最靠右的结点m或者是右子树最靠左的结点n一定是度为0或1的结点。

这样的话我们就可以把问题转化为将m或n的数据复制到要删除的数据位置来代替,在将m或n的原来位置的结点删除

2）如果p的度为1：直接让pre指向p的指针指向p的孩子（即将p删除后，让p唯一的孩子顶替p的位置）

3）如果p的度为0：直接删除

注意：这里度为0的情况我们也可以看作度为1的情况去处理，认为他也右一个孩子，只不过一个孩子是NULL孩子

递归查找的思路:在以r为根节点的树中，删除数据x----->递归

(1)x<r->data:问题转化为在以r->left为根的子树上删除x

(2)x>r->data :问题转化为在以r->right为根的子树上删除x

(3)x==r->data:r就是要被删除的节点，去根据r的度 判断如何删除

BSTNode* find_leftmaxx(BSTree p)
{
	while (p->right != NULL)
	{
		p = p->right;
	}
	return p;
}
BSTree delet(BSTree r, int k)
{
	if (k < r->data)
	{
		r->left = delet(r->left, k);
	}
	if (k > r->data)
	{
		r->right = delet(r->right, k);
	}
	if (k == r->data)
	{//r就是要被删除的节点 
		if (r->left != NULL && r->right != NULL)
		{//r的度为2
			//找到r的左子树中最靠右的节点
			BSTNode* lmaxx = find_leftmaxx(r->left);
			r->data = lmaxx->data;
			r->left = delet(r->left, lmaxx->data);//删掉顶替的节点 
		}
		else
		{//r的度为1/0（0也看成1） 
			BSTNode* p = r;
			if (r->left != NULL)
			{
				r = r->left;
			}
			else
			{
				r = r->right;
			}
			free(p);
			p = NULL;
		}

	}
	return r;//返回删除后的新树 
}
整体代码：
#include <iostream>
using namespace std;
//二叉链表存树
typedef struct BSTnode {
	int data;
	struct BSTnode* left;
	struct BSTnode* right;
}BSTNode, * BSTree;
BSTree initBST(int k)
{
	BSTree r = (BSTNode*)malloc(sizeof(BSTNode));
	//if(r==NULL)
	r->data = k;
	r->left = r->right = NULL;
	return r;
}
BSTree insert(BSTree r, int k)
{
	if (r == NULL)
	{
		BSTree s = (BSTNode*)malloc(sizeof(BSTNode));
		//if(s==NULL)
		s->data = k;
		s->left = s->right = NULL;
		return s;
	}
	if (k < r->data)
	{
		r->left = insert(r->left, k);
	}
	if (k > r->data)
	{
		r->right = insert(r->right, k);
	}
	return r;
}
//-----------非递归-------
BSTree insert_1(BSTree r, int k)
{
	BSTree s = (BSTNode*)malloc(sizeof(BSTNode));
	//if(s==NULL)
	s->data = k;
	s->left = s->right = NULL;
	//空树插入 
	if (r == NULL)
	{
		return s;
	}
	//非空树插入 
	BSTNode* p = r;//遍历
	BSTNode* pre = NULL;//p的父亲
	//遍历找插入位置 
	while (p != NULL)
	{
		if (k < p->data)
		{
			pre = p;
			p = p->left;
		}
		else {
			pre = p;
			p = p->right;
		}
	}
	//插入 
	if (k < pre->data)
	{
		pre->left = s;
	}
	else {
		pre->right = s;
	}
	return r;
}
void inOrder(BSTree r)
{
	if (r == NULL)
	{
		return;
	}
	inOrder(r->left);
	cout << r->data << endl;
	inOrder(r->right);
}
void find(BSTree r, int x)
{
	BSTNode* p = r;
	while (p != NULL)
	{
		if (x == p->data)
		{
			cout << "存在" << endl;
			break;
		}
		if (x < p->data)
		{
			p = p->left;
		}
		if (x > p->data)
		{
			p = p->right;
		}
	}
	if (p == NULL)
	{
		cout << "不存在" << endl;
	}
}
//-------删除------------------- 
BSTNode* find_leftmaxx(BSTree p)
{
	while (p->right != NULL)
	{
		p = p->right;
	}
	return p;
}
BSTree delet(BSTree r, int k)
{
	if (k < r->data)
	{
		r->left = delet(r->left, k);
	}
	if (k > r->data)
	{
		r->right = delet(r->right, k);
	}
	if (k == r->data)
	{//r就是要被删除的节点 
		if (r->left != NULL && r->right != NULL)
		{//r的度为2
			//找到r的左子树中最靠右的节点
			BSTNode* lmaxx = find_leftmaxx(r->left);
			r->data = lmaxx->data;
			r->left = delet(r->left, lmaxx->data);//删掉顶替的节点 
		}
		else
		{//r的度为1/0（0也看成1） 
			BSTNode* p = r;
			if (r->left != NULL)
			{
				r = r->left;
			}
			else
			{
				r = r->right;
			}
			free(p);
			p = NULL;
		}

	}
	return r;//返回删除后的新树 
}
int main()
{
	int n;
	int a[105];
	cin >> n;
	for (int i = 1; i <= n; i++)
	{
		cin >> a[i];
	}
	BSTree r = NULL;
	//-----递归版 不单独初始化根节点------------ 
		 /*
		 for(int i=1;i<=n;i++)
		{
			r=insert(r,a[i]);
		}
		 */
		 //-----递归版 单独初始化根节点------------- 
			  /*
			  r=initBST(a[1]);
			  for(int i=2;i<=n;i++)
			 {
				 r=insert(r,a[i]);
			 }
			 */
			 //------非递归版 ------------------ 
	for (int i = 1; i <= n; i++)
	{
		r = insert_1(r, a[i]);
	}
	//--------------------------- 
	inOrder(r);//中序遍历输出验证 
	cout << endl;
	//删除 
	int x;
	cin >> x;
	r = delet(r, x);
	inOrder(r);//中序遍历输出验证 
	printf("\n");

	return 0;
}
/*
14
8 6 13 5 7 9 14 1 12 3 11 2 4 10
*/

AD画PCB时如何设计线宽
weixin_42499230的博客
02-13 1363
AD如何设置线宽！
AD(第五部分---PCB设计规则设置及PCB手工布线)
wo12369874的博客
08-25 8661
正片层选择如上图所示的十字连接的理由：铜，导热，手动焊接加热时会产生虚焊的风险(回流焊温度高，不会有该风险)（电源是用来载流的(需要加宽)，信号线是用来通讯的）(可以在PWR处点击右键隐藏电源线PWR)过孔孔径大小*2=过孔直径(有正负2的误差) 如10的过孔孔径大小，过孔直径就是18~22。类电层连接方式(负片) 反焊盘设置(推荐设置为8mi) 正片层(信号走线层)下图右为不盖滤油，右图为开窗，有阻焊，防止滤油覆盖的。一般来说，焊盘选择十字连接，过孔选择全连接。29.Class,设计参数，规则的创建。
AD高级规则设置
11-02
Altium designer覆铜高级连接方式，高级间距规则，高级线宽规则
AD常用设置
最新发布
m0_68790422的博客
04-12 424
3.Comparator和ECO Generation是updata PCB时进行比较的类目，一般默认，使用Net Class更改PCB颜色时设置忽略这一条，比较和ECO重复的类目设置一个应该就可以。新版AD（AD17后）：首先Project Options中先设置勾选Generate Compon Class，元器件属性界面add Parameter，Paramter改名为ClassName。2.走线模式：选择是否预走线，即走线时是否走最后一段，在走线时按1切换。设置按空格时的旋转角度，默认90度。
PCB设计之线宽、线距规则设置
花开那年
04-21 2万+
1、阻抗的信号线 应该按照叠层计算出来的线宽、线距来设置。 比如射频信号（常规50R控制）、重要单端50R、差分90R、差分100R等信号线，通过叠层可计算出具体的线宽线距（下图所示）。 2、一般线宽、线距、过孔设置 一般正常情况下线宽线距控制到 6/6mil ，过孔选择 12mil（0.3mm）， 基本80%以上PCB生产厂商都能生产，生产的成本最低。 线宽线距最小控制到 4/4mil，过孔...
AD常用PCB设计规则介绍 （详细版）
qq_58662017的博客
08-06 6616
安全距离的各项规则以树形结构形式展开，用鼠标单击安全距离规则树中的一个规则名称，如polygon clearance，则对话框的右边区域将显示这个规则使用的范围和规则的约束特性---如polygon clearance规则约束PCB文件中的多边形敷铜与文件中其他的对象如走线、焊盘、过孔等的安全距离是0.5mm。PCB设计软件的锡膏层或锡膏防护层的数据就是用来制作钢模的，钢模上镂空的面积要比设计焊盘的面积小，该规则就是设置这个差值的最大值(即钢模上的镂空面积与设计焊盘的面积的差值，默认值为0)。
Altium Designer(AD)软件使用记录09-PCB布线部分之层叠设置、 规则设置
qq_31444421的博客
03-12 6010
Altium Designer(AD)软件使用记录09-PCB布线部分之层叠设置、 规则设置
PCB设计规则设置
m0_58083051的博客
03-22 4317
本文主要讲述了class以及PCB九大设计规则中的间距、线宽、过孔、铺铜四大规则的设计。
AD-----间距、线宽、阻焊、铺铜规则设置
nervous__的博客
01-19 3万+
AD-----间距、线宽、阻焊、铺铜规则设置
AD的pcb规则，如布线规则等
weixin_30768175的博客
09-22 908
1.过孔大小 2.（1）热风焊盘规则（2）覆铜管理器规则（3） （1）热风焊盘规则 （2）覆铜管理器规则 3.Clearance间距规则 4.线宽 5.丝印层与助焊层，铜皮的间距 6.过孔与过孔的间距 7.丝印层最小的线宽 8.丝印层到其它层的间距 9.丝印层到元器件的间距 转载于:https://www.cnblogs....
PCB安规间距规定.doc
05-28
PCB安规间距规定，简述PCB在设计阶段的安规规范，用于指导PCB的布线设计初学者规范设计做出符合安全规范的产品。
Altium Designer中几种高级的布线规则设置
08-27
在电子设计自动化（EDA）领域，Altium Designer是一款广泛使用的PCB设计软件，它提供了丰富的功能，包括高级的布线规则设置，以确保电路板设计的精确性和可靠性。本篇文章将详细探讨两种重要的布线规则：覆铜...
AltiumDesigner规则设置技巧,268条PCB Layout设计规范
09-16
在PCB（印制电路板）Layout设计中，规则设置不仅关乎电气性能，还涉及机械约束、制造可行性等多个方面。以下将详细阐述268条PCB Layout设计规范以及Altium Designer中的规则设置技巧。 1. **设计规则分类**：规则...
PCB规则设置教程：AD软件应用指南
在进行PCB（印刷电路板）设计时，规则设置是保证设计质量和避免生产问题的关键步骤。本文档详细介绍了在Altium Designer中设置PCB规则的各种方法和注意事项。 一、PCB规则的基本概念 在Altium Designer中，PCB规则...
5 使用AD设置常用的PCB的规则
geekYatao
04-23 4万+
PCB的规则决定了线宽，过孔大小，线、器件的最小间距等。所包含的信息非常多，初学先修改以下的规则。在PCB的界面点击至少要设置线宽和过孔宽度由于电源和地线尽量要宽一点，例如最大线宽可设置为20mil。宽度既可以对全部的网络设置，也可以对指定的网络设置。默认的过孔尺寸稍微有点大，可修改。10mil宽的线用16,24。20mil的可以是24,32 另有一些规则，需根据公司的规定和加工厂的工艺水平决定，...
【AD】【规则设置】【pcb】默认规则设置
m0_55251293的博客
09-25 1万+
间距、线宽、过孔和铺铜，以及丝印规则
（PCB系列五）AD20的PCB布线规则设定【※】
zxm8513优快云博客
04-13 1万+
AD20的规则库设定是PCB布线的首要工作，在布线初期就要设置好，布线的过程中还需要动态的变更，因此本篇总结了PCB的详细设计规则，供大家学习参考。本章主要介绍以上几个部分的设计情况。
Altium AD20常用的PCB设计规则：PCB设计规则管理器、线宽、线距、过孔、盖油、内电层焊盘样式、焊盘与覆铜连接方式
热门推荐
Mark_md的博客
05-07 5万+
PCB规则设计是PCB设计中至关重要的一项环节，它约束了电气要求、布线方式、器件摆放位置等信息，为后续的自动或手动布局、布线提供依据。完善的PCB规则设计，不仅可以减少设计中错误的产生，更能提高设计效率。 PCB设计规则管理器 打开AD，设计 - 规则，打开PCB设计规则管理器。 规则约束一共有10大类，分别是： 电气规则：包含间距、短路、开路等。 信号线规则：线宽、过孔、差分线、扇孔等。 贴片规则 阻焊规则 铺铜规则 测试点规则 生产部分规则 高速部分的规则 放置器件的规则 信号完整性分析的规则
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值