【C++】AVL树 红黑树

news2024/9/20 14:39:51

AVL树

AVL树也是二叉搜索树的一种。因为对于普通的二叉搜索树，当插入的数据在有序或接近有序的情况下，二叉搜索树很可能退化成单支树，导致查找效率低下。而AVL树就很好的解决了这个问题。
首先，AVL树是一棵二叉搜索树。同时对于AVL树中每个节点，它的左右子树高度之差的绝对值不超过1。
对于有n个节点的AVL树，其搜索时间复杂度可以稳定的保持在 O ( l o g 2 n ) O(log_2 n) O(log2​n)。
为了保证向AVL树中插入节点，仍保持其高度的平衡，可以引入平衡因子（平衡因子：右子树的高度 - 左子树的高度）来处理。

// AVL树节点的定义
template<class K, class V>
class AVLTreeNode
{
public:
	AVLTreeNode(const pair<K, V>& kv)
		: _kv(kv)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _bf(0)
	{}

	pair<K, V> _kv;
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	int _bf; //  balance factor
};

因为AVL树仍是二叉搜索树，所以AVL树的插入可以分两步进行：

  1. 按照二叉搜索树的方式插入新节点
  2. 调整平衡因子
// AVL树的插入
template<class K, class V>
class AVLTree
{
private:
	typedef AVLTreeNode<K, V> Node;
public:
	AVLTree(Node* root = nullptr)
		: _root(root)
	{}
	bool Insert(const pair<K, V>& kv)
	{
		/* 
		* 1.按照二叉搜索树的方式插入新节点
		*/
		
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (kv.first  > cur->_kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (kv.first < cur->_kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

		// 直接插入
		cur = new Node(kv);
		if (kv.first > parent->_kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;

		/*
		* 2.调整平衡因子
		*/

		while (parent)
		{
			// 新增在右，parent->_bf++; 新增在左，parent->_bf--;
			if (cur == parent->_right)
			{
				parent->_bf++;
			}
			else
			{
				parent->_bf--;
			}

			// 调整后，parent->_bf == 0, 说明parent插入前的平衡因子是 1 or -1，说明插入前左右子树一边高一边低，插入后两边一样高，
			// 即插入填上了矮的一边，插入后parent所在子树高度不变，不需要继续往上调整
			if (parent->_bf == 0)
			{
				break;
			}
			// 调整后，parent->_bf == 1 or -1, 说明parent插入前的平衡因子是0，插入前左右子树高度相等，插入后有一边变高了，
			// parent高度变了，需要继续往上更新
			else if (abs(parent->_bf) == 1)
			{
				parent = parent->_parent;
				cur = cur->_parent;
			}
			// 调整后，parent->_bf == 2 or -2, 说明parent插入前的平衡因子是 1 or -1，已经是平衡临界值，
			// 插入后变成了 2 or -2，打破平衡，parent所在子树需要进行 旋转处理
			else if (abs(parent->_bf) == 2)
			{
				// 根据节点插入位置的不同，AVL树的旋转分为四种
				
				// 新节点插入在较高右子树的右侧（右右）
				if (parent->_bf == 2 && cur->_bf == 1)
				{
					// 左单旋
					RotateL(parent);
				}
				// 新节点插入在较高左子树的左侧（左左）
				else if (parent->_bf == -2 && cur->_bf == -1)
				{
					// 右单旋
					RotateR(parent);
				}
				// 新节点插入在较高左子树的右侧（左右）
				else if (parent->_bf == -2 && cur->_bf == 1)
				{
					// 左右双旋
					RotateLR(parent);
				}
				// 新节点插入在较高右子树的左侧（右左）
				else if (parent->_bf == 2 && cur->_bf == -1)
				{
					// 右左双旋
					RotateRL(parent);
				}
				else
				{
					assert(false);
				}

				break;
			}
			// 调整后，不可能出现parent->_bf > 2 or < -2，否则一定出bug了
			else
			{
				assert(abs(parent->_bf) <= 2);
			}
		}

		return true;
	}
private:
	// 左单旋
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		
		parent->_right = subRL;
		if (subRL)
		{
			subRL->_parent = parent;
		}
		
		// 保存parent的双亲节点
		Node* ppNode = parent->_parent;

		subR->_left = parent;
		parent->_parent = subR;

		// parent作为整棵树的根存在
		if (_root == parent)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		// parent作为子树的根存在
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
			}
			else
			{
				ppNode->_right = subR;
			}
			subR->_parent = ppNode;
		}

		subR->_bf = parent->_bf = 0;
	}
	// 右单旋
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR)
		{
			subLR->_parent = parent;
		}

		Node* ppNode = parent->_parent;
		subL->_right = parent;
		parent->_parent = subL;

		if (_root == parent)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}
		subL->_bf = parent->_bf = 0;
	}
	// 左右双旋
	void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		
		// 保存subLR当前的平衡因子
		int bf = subLR->_bf;

		// 先左单旋
		RotateL(parent->_left);
		// 再右单旋
		RotateR(parent);

		// 此处对于平衡因子的调整，建议画图分析
		subLR->_bf = 0;
		if (bf == 1)
		{
			parent->_bf = 0;
			subL->_bf = -1;
		}
		else if (bf == -1)
		{
			parent->_bf = 1;
			subL->_bf = 0;
		}
		else if(bf == 0)
		{
			parent->_bf = 0;
			subL->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}
	// 右左双旋
	void RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		int bf = subRL->_bf;

		RotateR(parent->_right);
		RotateL(parent);

		subRL->_bf = 0;
		if (bf == 1)
		{
			parent->_bf = -1;
			subR->_bf = 0;
		}
		else if (bf == -1)
		{
			parent->_bf = 0;
			subR->_bf = 1;
		}
		else if (bf == 0)
		{
			parent->_bf = 0;
			subR->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}
private:
	Node* _root;
};

RotateL左单旋示意图：
在这里插入图片描述
RotateR右单旋示意图：
在这里插入图片描述
RotateLR左右双旋示意图：
在这里插入图片描述
在这里插入图片描述
RotateRL右左双旋示意图：
在这里插入图片描述
可以通过下面程序对AVL树的正确性做一个验证。

template<class K, class V>
class AVLTree
{
private:
	typedef AVLTreeNode<K, V> Node;
public:
	// 1.验证其为二叉搜索树
	void InOrderTraversal()
	{
		_InOrderTraversal(_root);
	}
	
	// 2.验证其为平衡树
	bool IsBalance()
	{
		return _IsBalance(_root);
	}
private:
	// 如果中序遍历为有序序列，则说明为二叉搜索树
	void _InOrderTraversal(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

		_InOrderTraversal(root->_left);
		cout << root->_kv.first << " : " << root->_kv.second << endl;
		_InOrderTraversal(root->_right);
	}
	
	// 要求每个节点的子树高度差的绝对值不超过1，并且高度差要和平衡因子相等
	bool _IsBalance(Node* root)
	{
		// 空树也算AVL树
		if (root == nullptr)
		{
			return true;
		}

		int leftHt = Height(root->_left);
		int rightHt = Height(root->_right);
		int diff = rightHt - leftHt;

		if (diff != root->_bf)
		{
			cout << root->_kv.first << "平衡因子异常" << endl;
			return false;
		}
		
		return abs(diff) < 2
			&& _IsBalance(root->_left)
			&& _IsBalance(root->_right);
	}
	int Height(Node* root)
	{
		if (root == nullptr)
			return 0;

		int leftHt = Height(root->_left);
		int rightHt = Height(root->_right);

		return max(leftHt, rightHt) + 1;
	}
private:
	Node* _root;
};

红黑树

红黑树也是二叉搜索树的一种。
在这里插入图片描述
红黑树的性质要求如下：

  1. 每个节点不是红色就是黑色
  2. 根节点是黑色的
  3. 如果一个节点是红色的，则它的两个孩子节点必须是黑色的（或者说不允许存在父子节点同时为红色）
  4. 对于每个节点，从该节点到其后代叶节点的所有简单路径上，都只包含相同数量的黑色节点
  5. 所有的叶节点都是黑色的（叶节点指的是NIL节点）

通过以上5条性质的约束，就可以确保红黑树中 最长路径 ≤ 2 × 最短路径 最长路径 \leq 2 \times 最短路径 最长路径≤2×最短路径，从而来保证了红黑树的平衡性能。
虽然红黑树的平衡性能比AVL的略差些，但插入同样的数据，红黑树旋转更少。

// 红黑树节点的定义
enum Colour
{
	RED,
	BLACK
};

template<class K, class V>
class RBTreeNode
{
public:
	RBTreeNode(const pair<K, V>& kv)
		: _kv(kv)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
	{}
	
	pair<K, V> _kv;
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;
	Colour _col;
};

因为红黑树仍是二叉搜索树，所以红黑树的插入可以分两步进行：

  1. 按照二叉搜索树的方式插入新节点
  2. 检测插入新节点后，红黑树的性质是否受到破坏，并做变色或旋转调整
template<class K, class V>
class RBTree
{
private:
	typedef RBTreeNode<K, V> Node;
public:
	RBTree(Node* root = nullptr)
		: _root(root)
	{}
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			// 根节点是黑色的
			_root->_col = BLACK;
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (kv.first > cur->_kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (kv.first < cur->_kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		// 直接插入新节点
		cur = new Node(kv);
		// 对于插入的新节点赋为红色
		cur->_col = RED;
		if (kv.first > parent->_kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;
		
		// 如果父节点存在且为黑，没有破坏红黑树的规则，不需要调整
		// 如果父节点存在且为红，破坏了性质3
		while (parent && parent->_col == RED)
		{
			// 此时祖父节点一定存在且为黑
			Node* grandparent = parent->_parent;
			assert(grandparent);
			assert(grandparent->_col == BLACK);
			
			// 关键看叔叔(节点)
			// parent 为 grandparent 的左孩子
			if (parent == grandparent->_left)
			{
				Node* uncle = grandparent->_right;
				// 情况一 uncle存在且为红
				if (uncle && uncle->_col == RED)
				{
					// 将 parent 和 uncle 改为黑，grandparent 改为红，
					parent->_col = uncle->_col = BLACK;
					grandparent->_col = RED;
					// 然后把 grandparent 当成 cur，继续向上调整
					cur = grandparent;
					parent = cur->_parent;
				}
				// 情况二三 uncle不存在，或uncle存在且为黑
				else
				{
					// parent 为 grandparent 的左孩子，且 cur 为 parent 的左孩子
					if (cur == parent->_left)
					{
						// 右单旋
						RotateR(grandparent);
						// 变色: parent 变黑，grandparent 变红
						parent->_col = BLACK;
						grandparent->_col = RED;
					}
					// parent 为 grandparent 的左孩子，且 cur 为 parent 的右孩子
					else
					{
						// 左右双旋
						RotateL(parent);
						RotateR(grandparent);
						// 变色: parent 变黑，grandparent 变红
						cur->_col = BLACK;
						grandparent->_col = RED;
					}
					break;
				}
			}
			// parent 为 grandparent 的右孩子
			else
			{
				Node* uncle = grandparent->_left;
				// 情况一 uncle存在且为红
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandparent->_col = RED;
					
					cur = grandparent;
					parent = cur->_parent;
				}
				// 情况二三 uncle不存在，或uncle存在且为黑
				else
				{
					// parent 为 grandparent 的右孩子，且 cur 为 parent 的右孩子
					if (cur == parent->_right)
					{
						RotateL(grandparent);
						
						parent->_col = BLACK;
						grandparent->_col = RED;
					}
					// parent 为 grandparent 的右孩子，且 cur 为 parent 的左孩子
					else
					{
						RotateR(parent);
						RotateL(grandparent);
						
						cur->_col = BLACK;
						grandparent->_col = RED;
					}
					break;
				}
			}
		}
		
		_root->_col = BLACK;
		return true;
	}
private:
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		if (subRL)
		{
			subRL->_parent = parent;
		}
		Node* ppNode = parent->_parent;

		subR->_left = parent;
		parent->_parent = subR;

		if (_root == parent)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
			}
			else
			{
				ppNode->_right = subR;
			}
			subR->_parent = ppNode;
		}
	}
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR)
		{
			subLR->_parent = parent;
		}

		Node* ppNode = parent->_parent;
		subL->_right = parent;
		parent->_parent = subL;

		if (_root == parent)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}
	}
private:
	Node* _root;
};

uncle存在且为红：
在这里插入图片描述
可以通过下面程序对红黑树的正确性做一个验证。

template<class K, class V>
class RBTree
{
private:
	typedef RBTreeNode<K, V> Node;
public:
	// 1.验证其为二叉搜索树
	void InOrderTraversal()
	{
		_InOrderTraversal(_root);
	}
	
	// 2. 通过红黑树的性质验证其平衡性
	bool IsBalance()
	{
		// 空树也算红黑树
		if (_root == nullptr)
		{
			return true;
		}
		
		// 验证性质2
		if (_root->_col == RED)
		{
			cout << "根节点不是黑色" << endl;
			return false;
		}

		// benchmark作为每条路径上黑色节点数量的基准值
		int benchmark = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				++benchmark;
			}

			cur = cur->_left;
		}

		return PrevCheck(_root, 0, benchmark);	
	}
private:
	// 如果中序遍历为有序序列，则说明为二叉搜索树
	void _InOrderTraversal(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

		_InOrderTraversal(root->_left);
		cout << root->_kv.first << " : " << root->_kv.second << endl;
		_InOrderTraversal(root->_right);
	}
	
	bool PrevCheck(Node* root, int blackNum, int benchmark)
	{
		if (root == nullptr)
		{
			// 验证性质4
			if (blackNum != benchmark)
			{
				cout << "路径上黑色节点数量不相等" << endl;
				return false;
			}
			else
			{
				return true;
			}
		}
		
		// 验证性质3
		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << "存在连续的红色节点" << endl;
			return false;
		}

		if (root->_col == BLACK)
		{
			++blackNum;
		}

		return PrevCheck(root->_left, blackNum, benchmark)
			&& PrevCheck(root->_right, blackNum, benchmark);
	}
private:
	Node* _root;
};

红黑树相比AVL树不追求绝对的平衡，其只需保证最长路径不超过最短路径的2倍即可，所以相对而言红黑树减少了插入时旋转的次数，在经常需要进行增删的结构中性能比AVL树更优，实际运用中也是红黑树更多。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1061541.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

appscan的两种手动探索扫描方式

appscan的两种手动探索扫描方式

文章目录 一、使用火狐FoxyProxy浏览器代理探索二、使用appscan内置浏览器探索 一、使用火狐FoxyProxy浏览器代理探索 首先火狐浏览器需安装FoxyProxy 先在扩展和主题里搜FoxyProxy 选FoxyProxy Standard,然后添加到浏览器就行 添加后浏览器右上角会有这个插件 打开apps…
阅读更多...
JVM篇---第三篇

JVM篇---第三篇

系列文章目录 文章目录 系列文章目录一、什么是Java虚拟机？为什么Java被称作是“平台无关的编程语言”？二、Java内存结构三、说说对象分配规则一、什么是Java虚拟机？为什么Java被称作是“平台无关的编程语言”？ Java虚拟机是一个可以执行Java字节码的虚拟机进程。Java源文…
阅读更多...
Maven 中引用其他项目jar包出现BOOT-INF问题

Maven 中引用其他项目jar包出现BOOT-INF问题

问题 在B项目中引入A项目的类&#xff0c;但是发现怎么也引入不进来 A项目打包之后&#xff0c;想在B项目中引用jar 在B项目中发现类文件无法引用 参考网上进行清缓存等一系列操作都没有解决。 最后发现引用的jar包中包含BOOT-INF&#xff0c; 然后去A项目中查找&#xff…
阅读更多...
云原生边缘计算KubeEdge安装配置

云原生边缘计算KubeEdge安装配置

1. K8S集群部署&#xff0c;可以参考如下博客 请安装k8s集群&#xff0c;centos安装k8s集群 请安装k8s集群&#xff0c;ubuntu安装k8s集群 2.安装kubEedge 2.1 编辑kube-proxy使用ipvs代理 kubectl edit configmaps kube-proxy -n kube-system #修改kube-proxy#大约在40多行…
阅读更多...
【动手学深度学习-Pytorch版】Transformer代码总结

【动手学深度学习-Pytorch版】Transformer代码总结

本文是纯纯的撸代码讲解&#xff0c;没有任何Transformer的基础内容~ 是从0榨干Transformer代码系列&#xff0c;借用的是李沐老师上课时讲解的代码。 本文是根据每个模块的实现过程来进行讲解的。如果您想获取关于Transformer具体的实现细节&#xff08;不含代码&#xff09;可…
阅读更多...
多个浮点数精确求和math.fsum()

多个浮点数精确求和math.fsum()

【小白从小学Python、C、Java】 【计算机等考500强证书考研】 【Python-数据分析】 多个浮点数精确求和 math.fsum() 选择题 执行结果输出为1.0的函数是? import math a[0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1] print("【执行】print(sum(a))") print(sum(a)) p…
阅读更多...
【应用层协议】HTTPS的加密流程

【应用层协议】HTTPS的加密流程

文章目录 1. 认识HTTPS2. 密文3. HTTPS加密流程3.1 对称加密3.2 非对称加密3.3 证书 1. 认识HTTPS HTTPS&#xff08;超文本传输协议安全&#xff09;也是一个应用层协议&#xff0c;它是在HTTP协议的基础上引入了一个加密层。 也就是HTTP协议传输文本的方式是明文&#xff0c;…
阅读更多...
7-16 城市间紧急救援 （综合最短路练习）

7-16 城市间紧急救援 （综合最短路练习）

本题链接&#xff1a;PTA | 程序设计类实验辅助教学平台 题目&#xff1a; 样例&#xff1a; 输入 4 5 0 3 20 30 40 10 0 1 1 1 3 2 0 3 3 0 2 2 2 3 2 输出 2 60 0 1 3 思路&#xff1a; 这道题是经典的综合最短路问题&#xff0c; 综合了 三种最短路方法&#xff0c;1.求…
阅读更多...
Flutter AI五子棋

Flutter AI五子棋

前言 在上一篇文章中&#xff0c;讲解了如何实现双人在本地对战的五子棋&#xff0c;但是只有一个人的时候就不太好玩&#xff0c;同时博主也没有把五子棋相关的文章写过瘾。那么这篇文章&#xff0c;我们来实现一个功能更加丰富的五子棋吧&#xff01;在设计五子棋的算法方面&…
阅读更多...
MongoDB数据库网站网页实例-编程语言Python+Django

MongoDB数据库网站网页实例-编程语言Python+Django

程序示例精选 PythonDjangoMongoDB数据库网站网页实例 如需安装运行环境或远程调试&#xff0c;见文章底部个人QQ名片&#xff0c;由专业技术人员远程协助&#xff01; 前言 这篇博客针对《PythonDjangoMongoDB数据库网站网页实例》编写代码&#xff0c;代码整洁&#xff0c;…
阅读更多...
【软件测试】软件测试的基础概念

【软件测试】软件测试的基础概念

一、一个优秀的测试人员需要具备的素质 技能方面&#xff1a; 优秀的测试用例设计能力&#xff1a;测试用例设计能力是指&#xff0c;无论对于什么类型的测试&#xff0c;都能够设计出高效的发现缺陷&#xff0c;保证产品质量的优秀测试用例。这就需要我们掌握设计测试用例的方…
阅读更多...
【Docker】初识 Docker，Docker 基本命令的使用，Dockerfile 自定义镜像的创建

【Docker】初识 Docker，Docker 基本命令的使用，Dockerfile 自定义镜像的创建

文章目录 前言&#xff1a;项目部署的挑战一、初识 Docker1.1 什么是 Docker1.2 Docker 与 虚拟机的区别1.3 镜像和容器以及镜像托管平台1.4 Docker的架构解析1.5 Docker 在 CentOS 中的安装 二、Docker 的基本操作2.1 操作 Docker 镜像命令2.1.1 镜像操作相关命令2.1.2 示例一…
阅读更多...
C/C++字符函数和字符串函数模拟实现与详解————长度不受限制的字符串函数

C/C++字符函数和字符串函数模拟实现与详解————长度不受限制的字符串函数

个人主页&#xff1a;点我进入主页 专栏分类&#xff1a;C语言初阶 C语言程序设计————KTV C语言小游戏 C语言进阶 C语言刷题 欢迎大家点赞&#xff0c;评论&#xff0c;收藏。 一起努力&#xff0c;一起奔赴大厂。 目录 1.前言 2strlen函数 3.strcpy函数…
阅读更多...
通过BeanFactotyPostProcessor动态修改@FeignClient的path

通过BeanFactotyPostProcessor动态修改@FeignClient的path

最近项目有个需求&#xff0c;要在启动后&#xff0c;动态修改FeignClient的请求路径&#xff0c;网上找到的基本都是在FeignClient里使用${…}&#xff0c;通过配置文件来定义Feign的接口路径&#xff0c;这并不能满足我们的需求 由于某些特殊原因&#xff0c;我们的每个接口…
阅读更多...
【算法|动态规划No.9】leetcodeLCR 091. 粉刷房子

【算法|动态规划No.9】leetcodeLCR 091. 粉刷房子

个人主页&#xff1a;兜里有颗棉花糖 欢迎 点赞&#x1f44d; 收藏✨ 留言✉ 加关注&#x1f493;本文由 兜里有颗棉花糖 原创 收录于专栏【手撕算法系列专栏】【LeetCode】 &#x1f354;本专栏旨在提高自己算法能力的同时&#xff0c;记录一下自己的学习过程&#xff0c;希望…
阅读更多...
2023/10/4 QT实现TCP服务器客户端搭建

2023/10/4 QT实现TCP服务器客户端搭建

服务器端&#xff1a; 头文件 #ifndef WIDGET_H #define WIDGET_H#include <QWidget> #include <QTcpServer> #include <QTcpSocket> #include <QList> #include <QMessageBox> #include <QDebug>QT_BEGIN_NAMESPACE namespace Ui { cla…
阅读更多...
便携式脑卒中检测仪是不是离现实不远了？

便携式脑卒中检测仪是不是离现实不远了？

摘要&#xff1a;本文介绍一个轻量级人工智能的应用--基于tinyML的便携式低成本脑部微波成像系统。参考资料为DOI&#xff1a; 10.1109/ISCAS46773.2023.10181746 医疗资源从来都是稀缺资源。 我们都经历过在医院CT和核磁共振室外排队的情况。即使您万分紧急&#xff0c;也只能…
阅读更多...
实验3.2 分期付款计算器

实验3.2 分期付款计算器

目录 实验目的‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬ 实验内容‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬…
阅读更多...
【算法与数据结构】归并排序的代码实现（详细图解）以及master公式的讲解

【算法与数据结构】归并排序的代码实现（详细图解）以及master公式的讲解

目录 1、归并排序 1.1、算法描述 1.2、图解说明 2、代码实现 3、master公式 3.1、公式以及结论 3.2、适用于某些特殊的递归 3.3、计算归并排序的时间复杂度 1、归并排序 归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用递归或者说是分治法&#xff08;Di…
阅读更多...
基于SpringBoot的桂林旅游景点导游平台

基于SpringBoot的桂林旅游景点导游平台

目录 前言 一、技术栈 二、系统功能介绍 用户信息管理 景点类型管理 景点信息管理 线路推荐管理 用户注册 线路推荐 论坛交流 三、核心代码 1、登录模块 2、文件上传模块 3、代码封装 前言 随着信息技术在管理上越来越深入而广泛的应用&#xff0c;管理信息系统的实…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023