[C++随笔录] 红黑树

news2025/1/11 0:04:34

红黑树

  • 红黑树的特点
  • 红黑树的模拟实现
    • 红黑树的底层结构
    • 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.coloradmin.cn/o/1195625.html

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

相关文章

什么是Selenium？如何使用Selenium进行自动化测试？

什么是Selenium？如何使用Selenium进行自动化测试？

什么是 Selenium&#xff1f; Selenium 是一种开源工具&#xff0c;用于在 Web 浏览器上执行自动化测试&#xff08;使用任何 Web 浏览器进行 Web 应用程序测试&#xff09;。   等等&#xff0c;先别激动&#xff0c;让我再次重申一下&#xff0c;Selenium 仅可以测试Web应用…
阅读更多...
实现跨域必须要知道的知识点

实现跨域必须要知道的知识点

目录 同源策略 cookie iframe和多窗口通信 片段识别符 window.postMessage() LocalStorage Storage接口&#xff1a; 概述 属性和方法 Storage.setItem() Storage.getItem() Storage.removeItem() Storage.clear() Storage.key() storage 事件 同源策略 浏览器…
阅读更多...
响应式少儿舞蹈培训网站模板源码

响应式少儿舞蹈培训网站模板源码

模板信息&#xff1a; 模板编号&#xff1a;6903 模板编码&#xff1a;UTF8 模板颜色&#xff1a;橙色 模板分类&#xff1a;学校、教育、培训、科研 适合行业&#xff1a;培训机构类企业 模板介绍&#xff1a; 本模板自带eyoucms内核&#xff0c;无需再下载eyou系统&#xf…
阅读更多...
从开源项目聊鱼眼相机的“360全景拼接”

从开源项目聊鱼眼相机的“360全景拼接”

目录 概述 从360全景的背景讲起 跨过参数标定聊透视变化 拼接图片后处理 参考文献 概述 写这篇文章的原因完全源于开源项目(GitHub参阅参考文献1)。该项目涵盖了环视系统的较为全貌的制作过程&#xff0c;包含完整的标定、投影、拼接和实时运行流程。该篇文章主要是梳理全…
阅读更多...
深入探析隔离CAN收发器NSI1050-DDBR各项参数

深入探析隔离CAN收发器NSI1050-DDBR各项参数

NSI1050-DDBR是一个隔离的CAN收发器&#xff0c;可以完全与ISO11898-2标准兼容。 NSI1050-DDBR集成了两个通道的数字隔离器和一个高电平可靠性CAN收发器。 数字隔离器是基于Novosense电容隔离技术的氧化硅隔离。 高度集成的解决方案可以帮助简化系统设计并提高可靠性。 NSI1050…
阅读更多...
【postgresql】CentOS7 安装pgAdmin 4

【postgresql】CentOS7 安装pgAdmin 4

CentOS7 安装PostgreSQL Web管理工具pgAdmin 4。 pgAdmin 是世界上最先进的开源数据库 PostgreSQL 最受欢迎且功能丰富的开源管理和开发平台。 下载地址&#xff1a; pgadmin-4 download pgAdmin 4分为桌面版和服务器版。 我们这里部署服务器版本。 安装RPM包。 安装源 s…
阅读更多...
使用IDEA工具处理git合并后的冲突的细节

使用IDEA工具处理git合并后的冲突的细节

使用 IDEA 处理合并(merge) 使用IDEA处理git合并如果遇到冲突&#xff0c;对冲突文件的不冲突部分需要处理吗&#xff1f;会自动将双方不冲突的部分合并吗&#xff1f; 比如如下&#xff0c;使用 IDEA 合并 branch1 到 branch2 分支&#xff0c;出现了冲突&#xff0c;如下图…
阅读更多...
Linux学习第二枪（yum，vim，g++/gcc，makefile的使用）

Linux学习第二枪（yum，vim，g++/gcc，makefile的使用）

前言&#xff1a;在我的上一篇Linux博客我已经讲了基础指令和权限&#xff0c;现在我们来学习如何在Linux上运行和执行代码 一&#xff0c;yum yum是Linux中的软件包管理器&#xff0c;软件包是有人一些人写好的代码和程序作出软件包放到服务器上&#xff0c;我们使用yum就能…
阅读更多...
DCMM咨询评估官方解答及各地补贴政策！

DCMM咨询评估官方解答及各地补贴政策！

1、DCMM是什么&#xff1f; DCMM是国家标准GB/T 36073-2018《数据管理能力成熟度评估模型》&#xff08;Data management Capability Maturity Model&#xff09;的简称&#xff0c;是我国数据管理领域首个正式发布的国家标准&#xff0c;旨在帮助企业利用先进的数据管理理念和…
阅读更多...
响应式青少年成长训练营培训网站模板源码

响应式青少年成长训练营培训网站模板源码

模板信息&#xff1a; 模板编号&#xff1a;28503 模板编码&#xff1a;UTF8 模板颜色&#xff1a;黑白 模板分类&#xff1a;学校、教育、培训、科研 适合行业&#xff1a;培训机构类企业 模板介绍&#xff1a; 本模板自带eyoucms内核&#xff0c;无需再下载eyou系统&#x…
阅读更多...
pyOCD

pyOCD

pyOCD 目录结构
阅读更多...
Proteus仿真--基于数码管设计的可调式电子钟

Proteus仿真--基于数码管设计的可调式电子钟

本文主要介绍基于51单片机的数码管设计的可调式电子钟实验&#xff08;完整仿真源文件及代码见文末链接&#xff09; 仿真图如下 其中数码管主要显示电子钟时间信息&#xff0c;按键用于调节时间 仿真运行视频 Proteus仿真--数码管设计的可调式电子钟&#xff08;仿真文件程…
阅读更多...
C 语言 switch 语句

C 语言 switch 语句

C 语言 switch 语句 在本教程中&#xff0c;您将通过一个示例学习在C语言编程中创建switch语句。 switch语句使我们可以执行许多代替方案中的一个代码块。 虽然您可以使用if…else…if阶梯执行相同的操作。但是&#xff0c;switch语句的语法更容易读写。 switch … case的语…
阅读更多...
下载思科模拟器Cisco packet Tracer7.0

下载思科模拟器Cisco packet Tracer7.0

一、下载地址 主要去思科官网下载&#xff0c;但是最新版本没有汉化。 官网地址&#xff1a;https://www.cisco.com/ 百度网盘链接&#xff1a;https://pan.baidu.com/s/1VPTDN7BRgXIWt7m1E_8FMQ?pwd1111 提取码&#xff1a;1111 下载时把它放到U盘里&#xff0c;如图。 解压…
阅读更多...
关于安卓刷机，小米手机，各种安卓手机，理念+实践，如：小米8

关于安卓刷机，小米手机，各种安卓手机，理念+实践，如：小米8

关于安卓刷机&#xff1a; 比刚买的时候 更加流畅&#xff0c;调节性能 狂暴模式&#xff0c;且无任何冗余软件和垃圾。 作为普通人&#xff0c;就是刷自己想要的系统&#xff0c;比如开发版。打开Root权限&#xff0c;第三方Rec TWRP&#xff0c;面具Magisk&#xff0c;LSPo…
阅读更多...
超全总结！探索性数据分析 (EDA)方法汇总！

超全总结！探索性数据分析 (EDA)方法汇总！

探索性数据分析&#xff08;EDA&#xff09;是一种系统地分析、可视化和总结数据集的过程&#xff0c;以获取洞察并更好地理解数据中潜在的模式和趋势。 EDA是任何数据分析项目中的重要步骤&#xff0c;因为它有助于识别数据中的潜在问题和偏见。EDA有助于为建模和进一步分析奠…
阅读更多...
极智芯 | 存算一体 弯道超车的希望

极智芯 | 存算一体 弯道超车的希望

欢迎关注我的公众号 [极智视界]&#xff0c;获取我的更多经验分享 大家好&#xff0c;我是极智视界&#xff0c;本文分享一下 存算一体 弯道超车的希望。 邀您加入我的知识星球「极智视界」&#xff0c;星球内有超多好玩的项目实战源码和资源下载&#xff0c;链接&#xff1a;…
阅读更多...
win11下安装odoo17（conda python11）

win11下安装odoo17（conda python11）

win11下安装odoo17 odoo17发行了&#xff0c;据说&#xff0c;UI做了很大改进&#xff0c;今天有空&#xff0c;体验一下 打开官方仓库&#xff1a; https://github.com/odoo/odoo 默认的版本已经变成17了 打开odoo/odoo/init.py&#xff0c;发现对python版本的要求也提高了…
阅读更多...
揭秘南卡开放式耳机创新黑科技，核心技术剑指用户痛点

揭秘南卡开放式耳机创新黑科技，核心技术剑指用户痛点

随着科技的进步和人们娱乐方式的升级&#xff0c;大家对听音工具的选择&#xff0c;从传统的耳机到蓝牙耳机再到AirPods这样的真无线耳机&#xff0c;而今年&#xff0c;也有一种全新的耳机爆发式涌入人们之中&#xff0c;那就是开放式耳机。 开放式耳机的出现&#xff0c;满足…
阅读更多...
Vuex：模块化Module

Vuex：模块化Module

由于使用单一状态树&#xff0c;应用的所有状态会集中到一个比较大的对象。当应用变得非常复杂时&#xff0c;store 对象就有可能变得相当臃肿。 这句话的意思是&#xff0c;如果把所有的状态都放在/src/store/index.js中&#xff0c;当项目变得越来越大的时候&#xff0c;Vue…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023