[C++随笔录] 红黑树

红黑树

  • 红黑树的特点
  • 红黑树的模拟实现
    • 红黑树的底层结构
    • insert的实现
      • 实现思路
      • 更新黑红比例的逻辑
      • insert的完整代码
    • insert的验证
  • 源码

红黑树的特点

  • 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是 Red或 Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的.

  • 红黑树的特点:

    1. 节点颜色不是红色就是黑色
    2. 根节点是黑色的
    3. 每一条路径的黑色节点数目是相同的, (注意: 这里的路径是从根节点到NIL(黑色)节点)
    4. 每一条路径不允许出现连续的红色节点

  • 路径是从根节点 到 NIL节点的

🗨️满足上面的条件, 为啥就能保证 红黑树确保没有一条路径会比其他路径长出俩倍呢?

  • 根据上述的特点, 我们可以得知:
    当 每条路径的黑色节点数目一定的情况下 , 最短路径是 全黑, 最长路径是 黑红相间的
    如果我们保证 最长路径 不超过 最短路径的二倍就可以了

红黑树的模拟实现

红黑树的底层结构

  1. 颜色类型
// 枚举
enum Color
{
	RED,
	BLACK
};
  1. RBTreeNode类
template<class K, class V>
struct RBTreeNode
{
public:
	RBTreeNode(const pair<K, V> kv)
		:_kv(kv)
	{}

public:
	pair<K, V> _kv;
	Color _color = BLACK;
	RBTreeNode<K, V>* _left = nullptr;
	RBTreeNode<K, V>* _right = nullptr;
	RBTreeNode<K, V>* _parent = nullptr;
};
  1. RBTree类
template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;

public:
	RBTree()
	{}

private:
	// 根节点
	Node*  _root = nullptr;
	// 记录旋转次数
	int RotateCount =  0;
}

insert的实现

实现思路

二叉搜索树的插入逻辑 + 更新黑红比例

bool Insert(const pair<K, V> kv)
{
	if (_root == nullptr)
	{
		// 根节点是黑色的
		_root = new Node(kv);
		_root->_color = BLACK;
		return true;
	}

	Node* parent = _root;
	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->_color = RED;

	// 链接cur 和 parent
	if (cur->_kv.first > parent->_kv.first)
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}
	cur->_parent = parent;

	// 更改黑红比例
	// ...
	// ...

	// 更新完黑红比例后, 就返回true
	return true;
}

🗨️ 不能出现连续的红色节点 ⇒ 我们插入节点给个黑色节点多好, 为啥还要给红色节点冒风险呢?


因为, 我们插入的节点颜色是 红色, 插入的位置就有两种可能:

  1. 插入到黑色节点的后面 — — 正常的情况, 不需要进行更新
  2. 插入到红色节点的后面 — — 出现连续的红色节点, 需要 更新这一条支路 (当前节点到祖宗节点这一条路径)中的黑红比例

更新黑红比例的逻辑

由于 插入前, 是符合红黑树的性质,
插入的节点是红色 ⇒ 插入后才会出现连续的红色节点

⇒ 设插入的新节点为 cur(红色) ,
则父亲节点 paren 为 红色, 祖父节点 grandfather 为 黑色 ⇒ 这才符合 插入前符合红黑树的特点, 插入后才会出现连续的红色节点的情况

其实, 更新 当前节点到 祖宗节点这一条路径的 黑红比例 的本质是 看uncle的情况
首先, 要确定 uncle 位于grandfather的哪一侧 && uncle不一定存在, 但parent一定存在
⇒ 要确定parent 位于 grandfather的那一侧:

  1. parent 位于 grandfather的左侧
  2. parent 位于 grandfather的右侧

其次, 才是 uncle 的存在情况 以及 颜色情况

  1. uncle存在且为红

  2. uncle不存在
    如果 uncle不存在 ⇒ cur为新增节点

  • 如果cur不是新增节点, 那么 parent后面的节点必定是黑色的, 那么就违反了 每一条路径的黑色节点的个数是相同

  1. uncle存在且为黑

    如果uncle存在, 那么必定是 黑色 ⇒ 那么 cur 也应该是 黑色.
    现在看到的cur 是红色的, 是由下面的更新上来的


通过上面的图示, 我们得出 : 插入时, uncle主要分为两种情况

  1. uncle存在且为红 — — 由于更新后的头结点为红 ⇒ 我们需要继续向上更新下去
  2. uncle不存在 或 uncle存在且为黑 — — 由于更新后的头结点为黑 ⇒ 我们不需要继续向上更新下去

insert的完整代码

bool Insert(const pair<K, V> kv)
{
	if (_root == nullptr)
	{
		// 根节点是黑色的
		_root = new Node(kv);
		_root->_color = BLACK;
		return true;
	}

	Node* parent = _root;
	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->_color = RED;

	// 链接cur 和 parent
	if (cur->_kv.first > parent->_kv.first)
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}
	cur->_parent = parent;

	// 更改黑红比例
	// 父亲节点存在且为红, 才有机会继续向上更新下去
	while (parent && parent->_color == RED)
	{
		Node* grandfather = parent->_parent;
		
		// parent 为 grandfather的左侧
		if (grandfather->_left == parent)
		{
			Node* uncle = grandfather->_right;

			// u存在且为红
			if (uncle && uncle->_color == RED)
			{
				// 颜色变化
				grandfather->_color = RED;
				parent->_color = uncle->_color = BLACK;

				// 继续向上调整
				cur = grandfather;
				parent = cur->_parent;
			}
			else // u不存在 或 u存在且为黑色
			{
				if (cur == parent->_left)
				{
					RotateR(grandfather);

					grandfather->_color = RED;
					parent->_color = BLACK;
				}
				else
				{
					RotateL(parent);
					RotateR(grandfather);

					cur->_color = BLACK;
					grandfather->_color = RED;
				}
				
				// 更新后的头节点为黑色, 不需要继续向上更新
				break;
			}
		}
		// parent 为 grandfather的右侧
		else if (grandfather->_right == parent)
		{
			Node* uncle = grandfather->_left;

			// u存在且为红
			if (uncle && uncle->_color == RED)
			{
				// 颜色变化
				grandfather->_color = RED;
				uncle->_color = parent->_color = BLACK;

				// 继续向上调整
				cur = grandfather;
				parent = cur->_parent;
			}
			// u不存在 或 u存在且为黑色
			else
			{
				if (parent->_right == cur)
				{
					RotateL(grandfather);

					parent->_color = BLACK;
					grandfather->_color = RED;
				}
				else
				{
					RotateR(parent);
					RotateL(grandfather);

					cur->_color = BLACK;
					grandfather->_color = RED;
				}
				
				// 更新后的头节点为黑色, 不需要继续向上更新
				break;
			}
		}
		else
		{
			assert("黑红比例失控!");
		}
	}
	
	// 有可能更新过程中会把 root更新为红色 
	// && root节点的颜色必须为黑色
	// -->暴力统一处理根节点的颜色
	_root->_color = BLACK;

	return true;
}

insert的验证

  1. 每一条路径的 黑节点个数相同 ⇒ 先找一个 基准值(root的左子树中 黑节点的个数)
    如果后面的路径中 有的黑节点的个数 跟 基准值不同, 那就返回false.
  2. 不能有连续的红节点 ⇒ 当前节点为红节点, 那么父亲节点不能为红节点
  3. root 节点的颜色要为 黑色

验证代码

// 外面调用接口
bool IsBalance()
{
	return IsBalance(_root);
}

bool IsBalance(Node* root)
{
	if (root == nullptr)
		return true;

	// root节点为红, 就直接返回false
	if (root->_color != BLACK)
	{
		return false;
	}

	// 基准值 -- root左子树中的黑节点个数
	int benchmark = 0;
	Node* cur = _root;
	while (cur)
	{
		if (cur->_color == BLACK)
			++benchmark;

		cur = cur->_left;
	}
	
	// 检查每条路径中黑节点个数 && 不能出现连续的红节点
	return CheckColour(root, 0, benchmark);
}

bool CheckColour(Node* root, int blacknum, int benchmark)
{
	// 到叶子节点, 比较路径中黑节点的个数 和 基准值
	if (root == nullptr)
	{
		if (blacknum != benchmark)
			return false;

		return true;
	}

	if (root->_color == BLACK)
	{
		++blacknum;
	}
	
	// 不能存在连续的红节点
	if (root->_color == RED && root->_parent && root->_parent->_color == RED)
	{
		cout << root->_kv.first << "出现连续红色节点" << endl;
		return false;
	}

	return CheckColour(root->_left, blacknum, benchmark)
		&& CheckColour(root->_right, blacknum, benchmark);
}

Height

// 外面调用接口
int Height()
{
	return Height(_root);
}

int Height(Node* root)
{
	if (root == nullptr)
		return 0;

	int left = Height(root->_left);
	int right = Height(root->_right);

	return left > right ? left + 1 : right + 1;
}

GetRotateCount

int GetRoateCount()
{
	return RotateCount;
}

测试程序

void rbt_test()
{
	const int N = 10000000;
	vector<int> v;
	v.reserve(N);
	srand((unsigned int)time(NULL));

	for (size_t i = 0; i < N; i++)
	{
		int ret = rand();
		v.push_back(ret);
		// v.push_back(i);
	}

	muyu::RBTree<int, int> rbt;
	for (auto e : v)
	{
		rbt.Insert(make_pair(e, e));
		// cout << "Insert:" << e << "->" << avl.Isbalance() << endl;
	}
	cout << "红黑树是否达标-> " << rbt.IsBalance() << endl;
	cout << "红黑树的高度-> " << rbt.Height() << endl;
	cout << "红黑树旋转的次数-> " << rbt.GetRoateCount() << endl;
}

int main()
{
	rbt_test();
	
	return 0;
}

运行结果:

红黑树是否达标-> 1
红黑树的高度-> 19
红黑树旋转的次数-> 19119

源码

#pragma once

#include<iostream>

using namespace std;

namespace muyu
{
	// 枚举
	enum Color
	{
		RED,
		BLACK
	};

	template<class K, class V>
	struct RBTreeNode
	{
	public:
		RBTreeNode(const pair<K, V> kv)
			:_kv(kv)
		{}

	public:
		pair<K, V> _kv;
		Color _color = BLACK;
		RBTreeNode<K, V>* _left = nullptr;
		RBTreeNode<K, V>* _right = nullptr;
		RBTreeNode<K, V>* _parent = nullptr;
	};

	template<class K, class V>
	class RBTree
	{
		typedef RBTreeNode<K, V> Node;

	public:
		RBTree()
		{}

		void RotateL(Node* parent)
		{
			++RotateCount;

			Node* cur = parent->_right;
			Node* grandfather = parent->_parent;
			Node* curleft = cur->_left;

			// 旋转核心
			parent->_right = curleft;
			cur->_left = parent;

			// 更新父亲
			// 1. parent && curleft
			if (curleft)
			{
				curleft->_parent = parent;
			}
			parent->_parent = cur;

			// 2.更新cur
			if (grandfather == nullptr)
			{
				cur->_parent = nullptr;
				_root = cur;
			}
			else
			{
				if (grandfather->_left == parent)
				{
					grandfather->_left = cur;
				}
				else
				{
					grandfather->_right = cur;
				}

				cur->_parent = grandfather;
			}

		}

		void RotateR(Node* parent)
		{
			++RotateCount;

			Node* cur = parent->_left;
			Node* grandfather = parent->_parent;
			Node* curright = cur->_right;

			// 旋转核心
			parent->_left = curright;
			cur->_right = parent;

			// 更新链接关系
			// 1. parent && curright
			if (curright)
			{
				curright->_parent = parent;
			}
			parent->_parent = cur;

			// 2.更新cur
			if (grandfather == nullptr)
			{
				cur->_parent = nullptr;
				_root = cur;
			}
			else
			{
				if (grandfather->_left == parent)
				{
					grandfather->_left = cur;
				}
				else
				{
					grandfather->_right = cur;
				}

				cur->_parent = grandfather;
			}
		}

		bool Insert(const pair<K, V> kv)
		{
			if (_root == nullptr)
			{
				// 根节点是黑色的
				_root = new Node(kv);
				_root->_color = BLACK;
				return true;
			}

			Node* parent = _root;
			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->_color = RED;

			// 链接cur 和 parent
			if (cur->_kv.first > parent->_kv.first)
			{
				parent->_right = cur;
			}
			else
			{
				parent->_left = cur;
			}
			cur->_parent = parent;

			// 更改黑红比例
			while (parent && parent->_color == RED)
			{
				Node* grandfather = parent->_parent;

				if (grandfather->_left == parent)
				{
					Node* uncle = grandfather->_right;

					// u存在且为红
					if (uncle && uncle->_color == RED)
					{
						// 颜色变化
						grandfather->_color = RED;
						parent->_color = uncle->_color = BLACK;

						// 继续向上调整
						cur = grandfather;
						parent = cur->_parent;
					}
					else // u不存在 或 u存在且为黑色
					{
						if (cur == parent->_left)
						{
							RotateR(grandfather);

							grandfather->_color = RED;
							parent->_color = BLACK;
						}
						else
						{
							RotateL(parent);
							RotateR(grandfather);

							cur->_color = BLACK;
							grandfather->_color = RED;
						}

						break;
					}
				}
				else if (grandfather->_right == parent)
				{
					Node* uncle = grandfather->_left;

					// u存在且为红
					if (uncle && uncle->_color == RED)
					{
						// 颜色变化
						grandfather->_color = RED;
						uncle->_color = parent->_color = BLACK;

						// 继续向上调整
						cur = grandfather;
						parent = cur->_parent;
					}
					// u不存在 或 u存在且为黑色
					else
					{
						if (parent->_right == cur)
						{
							RotateL(grandfather);

							parent->_color = BLACK;
							grandfather->_color = RED;
						}
						else
						{
							RotateR(parent);
							RotateL(grandfather);

							cur->_color = BLACK;
							grandfather->_color = RED;
						}

						break;
					}
				}
				else
				{
					assert("黑红比例失控!");
				}
			}

			// 暴力统一处理根节点的颜色
			_root->_color = BLACK;

			return true;
		}

		int Height()
		{
			return Height(_root);
		}

		int Height(Node* root)
		{
			if (root == nullptr)
				return 0;

			int left = Height(root->_left);
			int right = Height(root->_right);

			return left > right ? left + 1 : right + 1;
		}

		bool CheckColour(Node* root, int blacknum, int benchmark)
		{
			if (root == nullptr)
			{
				if (blacknum != benchmark)
					return false;

				return true;
			}

			if (root->_color == BLACK)
			{
				++blacknum;
			}

			if (root->_color == RED && root->_parent && root->_parent->_color == RED)
			{
				cout << root->_kv.first << "出现连续红色节点" << endl;
				return false;
			}

			return CheckColour(root->_left, blacknum, benchmark)
				&& CheckColour(root->_right, blacknum, benchmark);
		}

		bool IsBalance()
		{
			return IsBalance(_root);
		}

		bool IsBalance(Node* root)
		{
			if (root == nullptr)
				return true;

			if (root->_color != BLACK)
			{
				return false;
			}

			// 基准值
			int benchmark = 0;
			Node* cur = _root;
			while (cur)
			{
				if (cur->_color == BLACK)
					++benchmark;

				cur = cur->_left;
			}

			return CheckColour(root, 0, benchmark);
		}

		int GetRoateCount()
		{
			return RotateCount;
		}

	private:
		Node* _root = nullptr;
		int RotateCount = 0;
	};
}

十年磨一剑，霜刃未曾试。
今日把示君，谁有不平事。
— — 贾岛《剑客》

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【华为OD题库-007】代表团坐车-Java

【华为OD题库-007】代表团坐车-Java

题目 某组织举行会议&#xff0c;来了多个代表团同时到达&#xff0c;接待处只有一辆汽车&#xff0c;可以同时接待多个代表团&#xff0c;为了提高车辆利用率&#xff0c;请帮接待员计算可以坐满车的接待方案&#xff0c;输出方案数量。 约束: 1.一个团只能上一辆车&#xff0…
阅读更多...
YOLOv5改进之CODConv,全维动态卷积再改进

YOLOv5改进之CODConv,全维动态卷积再改进

目录 一、理论部分 网络结构 二、CODConv 代码 应用到YOLOv5中 一、理论部
阅读更多...
Linux shell编程学习笔记23：[] [[]]的用法小结

Linux shell编程学习笔记23：[] [[]]的用法小结

上回梳理 了Linux Shell编程中 () 、$()和 (())的用法&#xff0c;现在接着梳理 [] 和[[]]的用法。 1 单中括号&#xff08;方括号&#xff09;[] 1.1 检测某个条件是否成立 [和test等同&#xff0c;是 Shell 内置命令&#xff0c;用来检测某个条件是否成立。条件成立时退出状…
阅读更多...
试题：最大的矩形（给定直方图里面积最大的矩形）

试题：最大的矩形（给定直方图里面积最大的矩形）

问题描述 在横轴上放了n个相邻的矩形&#xff0c;每个矩形的宽度是1&#xff0c;而第i&#xff08;1 ≤ i ≤ n&#xff09;个矩形的高度是hi。这n个矩形构成了一个直方图。例如&#xff0c;下图中六个矩形的高度就分别是3, 1, 6, 5, 2, 3。 请找出能放在给定直方图里面积最大的…
阅读更多...
【华为OD：C++机试】Day-4

【华为OD：C++机试】Day-4

目录 &#x1f337;1. 排队游戏&#xff1a; &#x1f337;2. 购物&#xff1a; &#x1f337;3. 划分字符串&#xff1a; &#x1f337;4. MELON 的难题&#xff1a; &#x1f337;5. 荒岛求生&#xff1a; &#x1f337;6. 通过软盘拷贝文件&#xff1a; &#x1f337;7. 数字…
阅读更多...
呼叫中心系统如果对接大模型

呼叫中心系统如果对接大模型

电话机器人对接大模型的例子 介绍 自chatgpt3.5发布以来&#xff0c;各种大模型飞速发展&#xff0c;各行各业都有接入大模型的需求&#xff0c;呼叫中心行业非常适合通过接入大模型用AI来回答用户的各种咨询&#xff0c;降低人力资源&#xff0c;使用顶顶通呼叫中心中间件&a…
阅读更多...
使用JavaScript编写游戏平台数据爬虫程序

使用JavaScript编写游戏平台数据爬虫程序

目录 一、引言 二、准备工作 三、爬取数据 四、数据处理与存储 五、数据分析与利用 六、结论与展望 一、引言 随着网络技术的发展&#xff0c;数据已经成为企业、研究机构和个人的重要资源。数据可以帮助我们了解市场趋势、用户需求&#xff0c;甚至可以用于机器学习和人…
阅读更多...
【狂神说Java】linux详解

【狂神说Java】linux详解

✅作者简介&#xff1a;CSDN内容合伙人、信息安全专业在校大学生&#x1f3c6; &#x1f525;系列专栏 &#xff1a;狂神说Java &#x1f4c3;新人博主 &#xff1a;欢迎点赞收藏关注&#xff0c;会回访&#xff01; &#x1f4ac;舞台再大&#xff0c;你不上台&#xff0c;永远…
阅读更多...
Java 之 IO/NIO/OKIO

Java 之 IO/NIO/OKIO

BIO blocking io AIO Asynchronous IO 从内存读取到写入--输出 从外部到内存 -- 输入 OutputStream //文件不存在则自动创建 try {OutputStream outputStream new FileOutputStream("text.txt");outputStream.write(a);outputStream.write(b);} catch (IOExcep…
阅读更多...
小程序开发——小程序页面的配置与生命周期

小程序开发——小程序页面的配置与生命周期

目录 1.小程序的页面配置 2.页面的生命周期 3.页面跳转 4.页面间的参数传递 5.新闻客户端案例讲解 6.小结 1.小程序的页面配置 页面的配置设置app.json中的window配置项的内容&#xff08;页面中配置项会覆盖app.json的window中相同的配置项&#xff09;&#xff0c;其属…
阅读更多...
Milvus Cloud——LLM Agent 现阶段出现的问题

Milvus Cloud——LLM Agent 现阶段出现的问题

LLM Agent 现阶段出现的问题 由于一些 LLM&#xff08;GPT-4&#xff09;带来了惊人的自然语言理解和生成能力&#xff0c;并且能处理非常复杂的任务&#xff0c;一度让 LLM Agent 成为满足人们对科幻电影所有憧憬的最终答案。但是在实际使用过程中&#xff0c;大家逐渐发现了通…
阅读更多...
计算机网络（一）

计算机网络（一）

一、什么是计算机网络、计算机协议&#xff1f; 计算机网络就是由计算机作为收发端&#xff0c;不同计算机相互连接的网络&#xff0c;包括互联网&#xff08;Internet&#xff09;&#xff0c;公司或者家用网络&#xff08;intranet&#xff09;等等&#xff1b;其中Internet…
阅读更多...
MobaXterm 安装+使用

MobaXterm 安装+使用

目录 1 下载安装 1.1 官网下载(速度慢) 1.2 WebRA下载(不是最新版) 2 常用功能 2.1 基础设置 2.2 常用功能 1 下载安装 1.1 官网下载(速度慢) 点击MobaXterm官网,按下图↓↓步骤下载 1.2 WebRA下载(不是最新版) 点击WebRA网址,按下图↓↓步骤下载 2 常用功能 2.1 基础设…
阅读更多...
【仿真动画】人机协作机器人自动化产线仿真动画欣赏

【仿真动画】人机协作机器人自动化产线仿真动画欣赏

人机协作机器人自动化产线仿真动画 动画部分思维导图 机器人自动化产线仿真动画是利用三维动画技术对机器人自动化产线进行仿真模拟&#xff0c;以直观、形象的方式展示产线的运行情况。它具有以下作用&#xff1a; 提高沟通效率 机器人自动化产线的设计、实施和维护涉及多个部…
阅读更多...
Java面试题

Java面试题

一、项目面试题-消息队列 背景&#xff1a;在分布式系统中是如何处理高并发的。 由于在高并发的环境下&#xff0c;来不及同步处理用户发送的请求&#xff0c;则会导致请求发生阻塞。比如说&#xff0c;大量的insert&#xff0c;update之类的请求同时到达数据库MYSQL&#xff…
阅读更多...
C#源代码生成器深入讲解一

C#源代码生成器深入讲解一

C#源代码生成器 01 源代码生成器初体验 新建一个类库&#xff0c;一定是standard2.0版本&#xff0c;否则会出问题。引用Nuget包Microsoft.CodeAnalysis.Common新建一个类&#xff0c;继承自ISourceGenerator接口 //一定要写&#xff0c;制定语言 [Generator(LanguageNames.…
阅读更多...
python3GUI--PyQt5打包心得（二）nuitka、inno Setup（详细图文演示、附所有软件）

python3GUI--PyQt5打包心得（二）nuitka、inno Setup（详细图文演示、附所有软件）

文章目录 一&#xff0e;前言二&#xff0e;准备1.nuitka1.1介绍1.3项目地址1.3安装 2.mingw641.1介绍1.2下载安装 3.Inno Setup1.1介绍1.2安装 三&#xff0e;nuitka打包1.打包2.装mingw643.装ccahe4.打包完成 四&#xff0e;测试效果五&#xff0e;inno Setup制作安装软件1.配…
阅读更多...
微信小程序前端开发

微信小程序前端开发

目录 前言&#xff1a; 1. 框架选择和项目搭建 2. 小程序页面开发 3. 数据通信和接口调用 4. 性能优化和调试技巧 5. 小程序发布和上线 前言&#xff1a; 当谈到微信小程序前端开发时&#xff0c;我们指的是使用微信小程序框架进行开发的一种方式。在本文中&#xff0c;我…
阅读更多...
基于SpringBoot+Redis的前后端分离外卖项目-苍穹外卖(三)

基于SpringBoot+Redis的前后端分离外卖项目-苍穹外卖(三)

员工分页查询和账号启用禁用功能 1. 员工分页查询1.1 需求分析和设计1.1.1 产品原型1.1.2 接口设计 1.2 代码开发1.2.1 设计DTO类1.2.2 封装PageResult1.2.3 Controller层1.2.4 Service层接口1.2.5 Service层实现类1.2.6 Mapper层 1.3 功能测试1.4 代码完善 2. 启用禁用员工账号…
阅读更多...
FPGA与STM32_FSMC总线通信实验

FPGA与STM32_FSMC总线通信实验

FPGA与STM32_FSMC总线通信实验 内部存储器IP核的参数设置创建IP核FPGA代码STM32标准库的程序 STM32F407 上自带 FSMC 控制器&#xff0c;通过 FSMC 总线的地址复用模式实现STM32 与 FPGA 之间的通信&#xff0c;FPGA 内部建立 RAM 块&#xff0c;FPGA 桥接 STM32 和 RAM 块&…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站