C++红黑树(简单易懂)

news2024/11/30 8:31:56

C++红黑树

  • 红黑树
    • 红黑树的概念
  • 红黑树节点的定义
  • 红黑树的插入颜色变化
  • 红黑树的插入
  • 拷贝构造
  • 红黑树的验证
  • 全部代码实现
  • 红黑树与AVL树的比较
  • 红黑树的应用

🌏个人博客主页：个人主页

在这里插入图片描述

红黑树

红黑树的概念

红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。

通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。
在这里插入图片描述
红黑树的性质

  1. 每个结点不是红色就是黑色
  2. 根节点是黑色的
  3. 如果一个节点是红色的，则它的两个孩子结点是黑色的 (不能出现连续的红节点 父子节点的颜色: 黑 + 黑 黑 + 红 红 + 黑)
  4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点 (每条路径都包含相同数量的黑色节点)
  5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)

为什么满足上面的性质，红黑树就能保证：其最长路径中节点个数不会超过最短路径节点个数的两倍？

最短路径： 因为每一条路径均包含相同数目的黑色结点，所以路径最短就是全部都是黑节点。

最长路径： 因为红黑树当中不会出现连续的红色结点，并且每一条路径均包含相同数目的黑色结点所以最长路径就是一黑一红间隔。

在这里插入图片描述
补充说明：

规则五每个叶子结点都是黑色的意思是，在求路径的时候是从根节点到空时一条路径，而不是到叶子节点结束，只有在求路径相关的问题才会用到，平时不常用。
在这里插入图片描述
这里是特殊情况，全黑也满足红黑树的性质，一共有8条路径。

红黑树节点的定义

为了方便后序的旋转操作，我们将红黑树的结点定义为三叉链结构，并且这里还新加入了一个成员变量，用于表示结点的颜色，这里我们可以使用枚举来定义结点的颜色，这样可以增加代码的可读性和可维护性。

enum Color
{
	Red,  	//红色
	Black	//黑色
};

template <class K,class V>
struct RBTreeNode
{
	RBTreeNode<K, V>* _left;  // 左子节点指针
    RBTreeNode<K, V>* _right;  // 右子节点指针
    RBTreeNode<K, V>* _parent;  // 父节点指针

    pair<K, V> _kv;  // 键值对
    Color _color;  // 节点颜色

	RBTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_color(Red)
		,_kv(kv)
	{}
};

为什么构造结点时，默认将结点的颜色设置为红色？

如果我们插入的是黑色结点，那么插入路径上黑色结点的数目就比其他路径上黑色结点的数目多了一个，即破坏了红黑树的性质4，那么需要调整所以路径黑色节点的数量代价太大

如果插入的是红色的节点，那么就会出现连续的红色结点，即破坏了红黑树的性质3，此时我们需要对红黑树进行调整即可。

红黑树的插入颜色变化

当插入一个节点的时候如果父亲的节点是红色就需要继续进行调整，当父亲的颜色是红色的时候，父亲不可能是根，因为根一定是黑色，所以祖父节点一定存在，并且因为父亲节点为红色，所以祖父节点一定时黑色。
在这里插入图片描述

因为新节点的默认颜色是红色，因此：如果其双亲节点的颜色是黑色，没有违反红黑树任何性质，则不需要调整。

但当新插入节点的双亲节点颜色为红色时，就违反了性质三不能有连在一起的红色节点，此时需要对红黑树分情况来讨论。

约定：cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点

情况一: cur为红，p为红，g为黑，u存在且为红
在这里插入图片描述
如果g是根节点，调整完成后，需要将g改为黑色如果g是子树，g一定有双亲，且g的双亲如果是红色，需要继续向上调整。

在这里插入图片描述

情况二: cur为红，p为红，g为黑，u不存在/u存在且为黑

1、u不存在，此时cur是一定新增。
在这里插入图片描述

如果cur为红，p为红，g为黑，u不存在是向上调整的结果，
在这里插入图片描述

此时左边路径至少有两个黑色节点，左边路径有一个黑色节点，在新增之前就不是红黑树，故不可能，只能是cur新增的结果。

处理方式：

在这里插入图片描述

2，u存在且为黑，一定是由情况一变化过来的，
在这里插入图片描述
如果cur是新增，那么右边路径有两个黑色节点，左边路径有一个黑色节点，在新增之前就不是红黑树，故不可能，只能是不断向上调整变成的。

处理方式：
在这里插入图片描述

补充说明

还有一点我想说如果向上调整只能是由如图的情况变化而来的
在这里插入图片描述
当然，这里的cur四个位置的新增都可以，如果要向上新增，必须要求g变成红色，只有情况一可以通过调整颜色达到平衡，此时g才是红色。

对于情况二: cur为红，p为红，g为黑，u不存在/u存在且为黑，只能通过旋转+变色，但是调整之后祖父节点是黑色，这个后面会讲，先记着·，如果父节点是黑色就不会向上调整，因为此时已经符合红黑树的条件，无需继续向上调整。

红黑树的插入

上面的分析看不懂没关系，只要记住一下两种情况就可以：

当插入后需要调整的时候，cur为当前节点，p为父节点，g为祖父节点关系都是确定的，唯一变化的就是uncle的关系，所以只要重点分析uncle即可。

1，如果uncle存在且为红，直接变色即可

2，如果uncle不存在，或者存在且为黑，旋转 + 变色

代码如下：

bool insert(const pair<K,V>& kv)
{
 	if (_root == nullptr)
    {
        // 如果根节点为空，创建一个新节点作为根节点，并将其颜色设为黑色
        _root = new Node(kv);
        _root->_color = Black;
        return true;
    }

    Node* parent = nullptr;
    Node* cur = _root;

    // 在树中查找插入位置
    while (cur)
    {
        if (cur->_kv.first > kv.first)
        {
            // 键值比当前节点小，向左子树查找
            parent = cur;
            cur = cur->_left;
        }
        else if (cur->_kv.first < kv.first)
        {
            // 键值比当前节点大，向右子树查找
            parent = cur;
            cur = cur->_right;
        }
        else
        {
            // 键值已存在，返回false
            return false;
        }
    }

    // 创建新节点并插入到正确位置
	cur = new Node(kv);
	if (parent->_kv.first > kv.first)
	{
		parent->_left = cur;
	}
	else
	{
		parent->_right = cur;
	}

	cur->_parent = parent;

	while (parent && parent->_color == Red)
	{
		Node* grandfather = parent->_parent;

		if (grandfather->_left == parent)
		{
			//    g
			//  p   u
			Node* uncle = grandfather->_right;
			//u存在且为红，变色继续往上处理
			if (uncle && uncle->_color == Red)
			{
				parent->_color = Black;
				uncle->_color = Black;
				
				grandfather->_color = Red;

				cur = grandfather;
				parent = cur->_parent;
			}
			else if (uncle == nullptr || uncle->_color == Black)
			{
				//      g
				//   p	   u
				//c
				//u存在且为黑或者不存在 -> 旋转 + 变色
				if (parent->_left == cur)
				{
					RotateR(grandfather);

					parent->_color = Black;
					grandfather->_color = Red;

				}
				//      g
				//   p	   u
				//		c
				//u存在且为黑或者不存在 -> 旋转 + 变色
				else
				{
					RotateL(parent);
					RotateR(grandfather);

					cur->_color = Black;
					grandfather->_color = Red;
				}

				//p是黑色不需要继续往上
				break;
			}
		}
		else
		{
			//    g
			//  u   p
			Node* uncle = grandfather->_left;
			if (uncle && uncle->_color == Red)
			{
				uncle->_color = parent->_color = Black;
				grandfather->_color = Red;

				cur = grandfather;
				parent = cur->_parent;
			}
			else if (uncle == nullptr || uncle->_color == Black)
			{
				//    g
				// u     p
				//         c
				if (parent->_right == cur)
				{
					RotateL(grandfather);

					parent->_color = Black;
					grandfather->_color = Red;
				}
				else
				{
					//    g
					// u     p
					//    c
					RotateR(parent);
					RotateL(grandfather);

					cur->_color = Black;
					grandfather->_color = Red;
				}

				break;
			}
		}

	}
	//如果是情况一不断向上调整,当cur = _root的时候,需要把根变为黑
	_root->_color = Black;
	return true;
}

拷贝构造

我们看一下这个代码是否有问题

Node* _Copy(Node* root)
{
	if (root == nullptr)
	{
		return nullptr;
	}

	Node* newnode = new Node(root->_kv);
	newnode->_color = root->_color;
	newnode->_parent = root->_parent;

	newnode->_left = _Copy(root->_left);
	newnode->_right = _Copy(root->_right);

	return newnode;
}

乍一看好像没问题，但是仔细一想就会发现爹不是一个爹呀，不能把别人的父亲当成自己的爹，所以要增加一个参数传自己的父亲。

Node* _Copy(Node* root,Node* parent)
{
	if (root == nullptr)
	{
		return nullptr;
	}

	Node* newnode = new Node(root->_kv);
	newnode->_color = root->_color;
	newnode->_parent = parent;

	newnode->_left = _Copy(root->_left,newnode);
	newnode->_right = _Copy(root->_right,newnode);

	return newnode;
}

该开始根的父亲是nullptr，所以直接传过去就ok了。

RBTree(const RBTree<K, V>& t)
{
	_root = _Copy(t._root, nullptr);
}

红黑树的验证

红黑树的检测分为两步：

  1. 检测其是否满足二叉搜索树(中序遍历是否为有序序列)
void InOrder()
{
	_InOrder(_root);
}

void _InOrder(Node* root)
{
	if (root == nullptr)
	{
		return;
	}

	_InOrder(root->_left);
	cout << root->_kv.first << " : " << root->_kv.second << endl;
	_InOrder(root->_right);
}
  1. 检测其是否满足红黑树的性质
bool IsBalance()
{
    if (_root == nullptr)
    {
        // 如果根节点为空，认为是平衡的
        return true;
    }

    if (_root->_color == Red)
    {
        // 根节点为红色，不符合红黑树性质
        return false;
    }

    int refNum = 0;  // 记录从根节点到所有叶子节点路径上的黑色节点个数

    Node* cur = _root;
    while (cur)
    {
        if (cur->_color == Black)
        {
            refNum++;  // 统计从根节点到叶子节点路径上的黑色节点个数
        }

        cur = cur->_left;  // 遍历到最左边的节点
    }

    return Check(_root, 0, refNum);  // 调用辅助函数进行检查
}

bool Check(Node* root, int BlackNum, const int refNum)
{
    if (root == nullptr)
    {
        // 如果遍历到空节点，检查路径上的黑色节点个数是否符合预期
        if (refNum != BlackNum)
        {
            return false;
        }

        return true;
    }

    if (root->_color == Red && root->_parent->_color == Red)
    {
        // 如果当前节点和父节点都是红色，不符合红黑树性质
        return false;
    }

    if (root->_color == Black)
    {
        BlackNum++;  // 遇到黑色节点，路径上的黑色节点个数加1
    }

    // 递归检查左右子树
    return Check(root->_left, BlackNum, refNum) && Check(root->_right, BlackNum, refNum);
}

这段代码实现了检查红黑树是否符合平衡性质的功能。其中 IsBalance 方法用于检查整棵树，首先判断根节点的颜色是否为红色，然后统计从根节点到叶子节点路径上的黑色节点个数，最后调用辅助函数 Check 进行递归检查。

Check 方法递归地检查每个节点，包括以下情况：

1，当遍历到空节点时，检查路径上的黑色节点个数是否符合预期。
2，当当前节点和父节点都是红色时，不符合红黑树性质，返回 false。
3，遇到黑色节点时，路径上的黑色节点个数加1。

最终，通过递归检查左右子树的方式，判断整棵树是否符合红黑树的平衡性质。

全部代码实现

#pragma once
#include <iostream>
using namespace std;

enum Color
{
	Red,  	//红色
	Black	//黑色
};

template <class K,class V>
struct RBTreeNode
{
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;

	pair<K, V> _kv;
	Color _color;

	RBTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_color(Red)
		,_kv(kv)
	{}
};

template<class K,class V>
class RBTree
{
	typedef RBTreeNode<K,V> Node;
public:
	RBTree() = default;

	RBTree(const RBTree<K, V>& t)
	{
		_root = _Copy(t._root, nullptr);
	}

	Node* Copy()
	{
		return _Copy(_root);
	}

	~RBTree()
	{
		Destroy(_root);
	}

	const RBTree<K, V>& operator=(RBTree<K, V> t)
	{
		swap(_root, t._root);

		return *this;
	}



	Node* find(const K& key)
	{
		if (_root == nullptr)
		{
			return;
		}

		Node* cur = _root;

		while (cur)
		{
			if (cur->_kv.first > key)
			{
				cur = cur->_left;
			}
			else if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else
			{
				return cur;
			}
		}

		return nullptr;
	}

	bool IsBalance()
	{
		if (_root == nullptr)
		{
			return true;
		}

		if (_root->_color == Red)
		{
			return false;
		}

		int refNum = 0;

		Node* cur = _root;
		while (cur)
		{
			if (cur->_color == Black)
			{
				refNum++;
			}

			cur = cur->_left;
		}

		return Check(_root, 0,refNum);
	}

	bool Check(Node* root, int BlackNum,const int refNum)
	{
		if (root == nullptr)
		{
			if (refNum != BlackNum)
			{
				return false;
			}

			return true;
		}

		if (root->_color == Red && root->_parent->_color == Red)
		{
			return false;
		}

		if (root->_color == Black)
		{
			BlackNum++;
		}

		return Check(root->_left,BlackNum,refNum) && Check(root->_right,BlackNum,refNum);
	}

	bool insert(const pair<K,V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_color = Black;
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;

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

		cur = new Node(kv);
		if (parent->_kv.first > kv.first)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}

		cur->_parent = parent;

		while (parent && parent->_color == Red)
		{
			Node* grandfather = parent->_parent;

			if (grandfather->_left == parent)
			{
				//    g
				//  p   u
				Node* uncle = grandfather->_right;
				if (uncle && uncle->_color == Red)
				{
					parent->_color = Black;
					uncle->_color = Black;
					
					grandfather->_color = Red;

					cur = grandfather;
					parent = cur->_parent;
				}
				else if (uncle == nullptr || uncle->_color == Black)
				{
					//      g
					//   p	   u
					//c
					//u存在且为红，变色继续往上处理
					if (parent->_left == cur)
					{
						RotateR(grandfather);

						parent->_color = Black;
						grandfather->_color = Red;

					}
					//      g
					//   p	   u
					//		c
					//u存在且为黑或者不存在 -> 旋转 + 变色
					else
					{
						RotateL(parent);
						RotateR(grandfather);

						cur->_color = Black;
						grandfather->_color = Red;
					}

					//p是黑色不需要继续往上
					break;
				}
			}
			else
			{
				//    g
				//  u   p
				Node* uncle = grandfather->_left;
				if (uncle && uncle->_color == Red)
				{
					uncle->_color = parent->_color = Black;
					grandfather->_color = Red;

					cur = grandfather;
					parent = cur->_parent;
				}
				else if (uncle == nullptr || uncle->_color == Black)
				{
					//    g
					// u     p
					//         c
					if (parent->_right == cur)
					{
						RotateL(grandfather);

						parent->_color = Black;
						grandfather->_color = Red;
					}
					else
					{
						//    g
						// u     p
						//    c
						RotateR(parent);
						RotateL(grandfather);

						cur->_color = Black;
						grandfather->_color = Red;
					}

					break;
				}
			}

		}

		_root->_color = Black;
		return true;
	}

	void InOrder()
	{
		_InOrder(_root);
	}
private:
	void Destroy(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

		Destroy(root->_left);
		Destroy(root->_right);

		delete root;
	
	}

	/*Node* _Copy(Node* root)
	{
		if (root == nullptr)
		{
			return nullptr;
		}

		Node* newnode = new Node(root->_kv);
		newnode->_color = root->_color;
		newnode->_parent = root->_parent;

		newnode->_left = _Copy(root->_left);
		newnode->_right = _Copy(root->_right);

		return newnode;
	}*/

	Node* _Copy(Node* root,Node* parent)
	{
		if (root == nullptr)
		{
			return nullptr;
		}

		Node* newnode = new Node(root->_kv);
		newnode->_color = root->_color;
		newnode->_parent = parent;

		newnode->_left = _Copy(root->_left,newnode);
		newnode->_right = _Copy(root->_right,newnode);

		return newnode;
	}

	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

		_InOrder(root->_left);
		cout << root->_kv.first << " : " << root->_kv.second << endl;
		_InOrder(root->_right);
	}

	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		Node* ppnode = parent->_parent;

		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

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

		if (ppnode == nullptr)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subR;
			}
			else
			{
				ppnode->_right = subR;
			}

			subR->_parent = ppnode;
		}

	}

	//           p
	//      subL		
	//	cur		 subLR
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		Node* ppnode = parent->_parent;

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

		subL->_right = parent;
		parent->_parent = subL;

		if (ppnode == nullptr)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subL;
			}
			else
			{
				ppnode->_right = subL;
			}

			subL->_parent = ppnode;
		}
	}

	Node* _root = nullptr;
};

红黑树与AVL树的比较

红黑树和AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是O( l o g 2 N log_2 N log2​N)，红黑树不追求绝对平衡，其只需保证最长路径不超过最短路径的2倍，相对而言，降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多

红黑树的应用

  1. C++ STL库 – map/set、mutil_map/mutil_set
  2. Java 库
  3. linux内核
  4. 其他一些库
    在这里插入图片描述

在这里插入图片描述

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

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

相关文章

Java并发 - 线程池

Java并发 - 线程池

文章目录 总体设计常见线程池FixedThreadPoolCachedThreadPoolSingleThreadPoolThreadPoolExecutor 核心参数工作原理生产者消费者模型创建线程池提交任务任务提交方式任务提交流程executeaddWorker Worker队列线程运行 runWoker获取任务销毁工作线程线程池关闭shutdown/shutdo…
阅读更多...
维修数据屏：重塑热力公司运维管理新格局

维修数据屏：重塑热力公司运维管理新格局

在热力公司的运维管理中&#xff0c;高效的报修和维修流程是确保系统稳定运行的关键。随着科技的发展&#xff0c;维修数据屏的出现为热力公司的运维工作带来了重大变革。 一、传统热力运维面临的挑战 过去&#xff0c;热力公司在报修和维修方面存在诸多问题&#xff0c;给运维…
阅读更多...
基于Java的超市管理系统（源码+定制+解答）

基于Java的超市管理系统（源码+定制+解答）

博主介绍&#xff1a; ✌我是阿龙&#xff0c;一名专注于Java技术领域的程序员&#xff0c;全网拥有10W粉丝。作为CSDN特邀作者、博客专家、新星计划导师&#xff0c;我在计算机毕业设计开发方面积累了丰富的经验。同时&#xff0c;我也是掘金、华为云、阿里云、InfoQ等平台…
阅读更多...
创建包含可导入浏览器信任的SSL自签名证书

创建包含可导入浏览器信任的SSL自签名证书

问题&#xff1a;现在的三大浏览器&#xff0c;chrome、edge、firefox 一般都默认启用https检查&#xff0c;这就要求我们自建的局域网内的网址和其他诸如nextcloud、photoprism、tiddlywiki等应用也必须要有证书。解决方法是使用openssl自己生成一个。由此则会再衍生出一个问题…
阅读更多...
哪款宠物空净运行吸毛好、噪音小？希喂、霍尼韦尔、安德迈测评！

哪款宠物空净运行吸毛好、噪音小？希喂、霍尼韦尔、安德迈测评！

作为宠物领域目前最火热的产品&#xff0c;宠物空气净化器的讨论度一直很高。身为铲屎官的我在产品刚出的时候就购入了一台&#xff0c;结果让我非常失望&#xff01; 抛开产品效果不提&#xff0c;它运行起来的声音实在太大了&#xff01;我家猫根本不愿意靠近&#xff0c;每…
阅读更多...
定焦镜头可以改变焦距吗？

定焦镜头可以改变焦距吗？

1、问题背景 焦距是镜头的一个固有光学特性&#xff0c;和镜头设计相关&#xff0c;所谓定焦镜头&#xff0c;焦距肯定是固定不变的。 但有个问题一直有点疑惑&#xff0c;焦距是镜头中心到焦点的距离&#xff0c;当我们拧动镜头调焦的过程&#xff0c;就是为了使得焦点成像在传…
阅读更多...
信息安全保障人员认证（CISAW）全攻略

信息安全保障人员认证（CISAW）全攻略

由中国网络安全审查认证和市场监管大数据中心耗时六年&#xff0c;汇聚业界专家、企业翘楚、高校及研究机构学者共同精心打磨而成的针对信息安全保障的不同专业技术方向、应用领域和保障岗位&#xff0c;依循国际标准 ISO/IEC 17024《人员认证机构通用要求》所构建的、多层次的…
阅读更多...
LabVIEW提高开发效率技巧----减少UI更新频率

LabVIEW提高开发效率技巧----减少UI更新频率

在LabVIEW开发中&#xff0c;图形化用户界面&#xff08;UI&#xff09;的更新频率对程序的响应速度有着显著影响。频繁的UI更新会占用大量资源&#xff0c;导致系统性能下降。本文将详细介绍如何通过减少UI更新频率来提升LabVIEW程序的运行效率&#xff0c;从多个角度进行分析…
阅读更多...
TCP/UDP通信协议

TCP/UDP通信协议

TCP通讯时序 下图是一次TCP通讯的时序图。TCP连接建立断开。包含大家熟知的三次握手和四次挥手。 在这个例子中&#xff0c;首先客户端主动发起连接&#xff08;connet&#xff09;、发送请求&#xff0c;然后服务器端响应请求&#xff0c;然后客户端主动关闭连接。两条竖线表…
阅读更多...
多功能校准仪怎么进行计量校准？

多功能校准仪怎么进行计量校准？

多功能校准仪计量校准是计量行业常会进行的一种校准&#xff0c;因为其多功能校准仪的普遍适用性&#xff0c;以及其计量校准技术也是在行业内比较通用&#xff0c;那么具体多功能校准仪计量校准怎么进行呢&#xff1f; 校准方法 一、在多功能校准仪的输出范围内&#xff0c;布…
阅读更多...
观察者模式的思考

观察者模式的思考

观察者模式由来 观察者模式&#xff08;Observer Pattern&#xff09;是一种行为型设计模式&#xff0c;它的起源可以追溯到20世纪90年代初&#xff0c;由设计模式四人帮&#xff08;Erich Gamma, Richard Helm, Ralph Johnson 和 John Vlissides&#xff09;在其著作《设计模…
阅读更多...
反走样算法（MSAA、TAA、FXAA、DLSS）

反走样算法（MSAA、TAA、FXAA、DLSS）

光栅化的采样过程会导致图形走样,走样有很多种形式: 锯齿 摩尔纹 走样的本质原因是采样速度跟不上信号变化的速度 采样频率低,使得我们将连续变化的信号离散化. 反走样方法 anti-alisaing MSAA 多重采样反走样 超采样 优点&#xff1a; 对几何反走样效果良好 缺点…
阅读更多...
razor TagHelper 汇总、HtmlHelper 汇总

razor TagHelper 汇总、HtmlHelper 汇总

Tag Helper Tag Helpers 的范围由 addTagHelper 和 removeTagHelper 进行控制&#xff0c;并且 “!” 为退出字符。 addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers // 手动高亮 asp-for 》》 Label <label asp-for"userName"></label>》》生…
阅读更多...
你的炼丹炉选对GPU卡了吗？

你的炼丹炉选对GPU卡了吗？

现在抢GPU卡搞智算、搞AI模型训练的都太火了。 无论你是一个游戏爱好者还是一个赛博炼丹师&#xff08;大模型训练&#xff09;&#xff0c;英伟达GPU卡选型都将是绕不过的一道命题。 那么重点来了&#xff0c;如何在琳琅满目的各种型号GPU卡中选取一款合适且性价比高的呢&…
阅读更多...
zookeeper实现RMI服务，高可用，HA

zookeeper实现RMI服务，高可用，HA

这可不是目录 1.RMI原理与说明1.1含义1.2流程1.3rmi的简单实现1.4RMI的局限性 2.zookeeper实现RMI服务&#xff08;高可用、HA&#xff09;2.1实现原理2.2高可用分析2.3zookeeper实现2.3.1代码分析2.3.2公共部分2.3.3服务端2.3.4客户端2.3.5运行与部署2.3.6效果展示与说明 1.RM…
阅读更多...
Spring Boot: 构建高效中小型医院网站

Spring Boot: 构建高效中小型医院网站

1 绪论 1.1研究背景 随着计算机技术的成熟、普及&#xff0c;现代信息技术革命的迅猛发展,正冲击并进而改变着经济和社会结构。信息化的程度已经成为一个国家&#xff0c;一个企业&#xff0c;一个组织仍至一个人发展的基础和竞争成败的关键。 在实际的生活中&#xff0c;用户都…
阅读更多...
软件评测CNAS资质获取流程

软件评测CNAS资质获取流程

软件评测实验室如有意向申请 CNAS 检验机构认可&#xff0c;首先需要依据 CNAS 的认可准则建立管理体系&#xff0c;正式运行6个月以上&#xff0c;自我评估满足 CNAS 认可条件后可向 CNAS 提交申请。软件评测实验室CNAS认可的整体流程如图所示&#xff0c;后面的内容针对每个环…
阅读更多...
数据结构之单链表详解：从原理到C语言实现

数据结构之单链表详解：从原理到C语言实现

一、 什么是单链表&#xff1f; 单链表&#xff08;Singly Linked List&#xff09;是一种线性数据结构&#xff0c;它的特点是每个节点通过指针链接到下一个节点。不同于顺序表&#xff08;数组&#xff09;&#xff0c;链表的每个元素&#xff08;节点&#xff09;并不存储在…
阅读更多...
【简单版】通过 Window.performance 实现前端页面(性能)监控

【简单版】通过 Window.performance 实现前端页面(性能)监控

1 背景 前端监控系统告警xx接口fetchError 问题&#xff1a;前端监控系统没有更多的错误信息&#xff0c;查询该fetch请求对应的接口日志返回200状态码、无请求异常记录&#xff0c;且后台能查到通过该fetch请求成功发送的数据。那是前端页面的错误还是前端监控系统的问题&…
阅读更多...
yjs机器学习常见算法01——KNN（1）（K—近邻算法）

yjs机器学习常见算法01——KNN（1）（K—近邻算法）

1.K—近邻算法 的含义&#xff1a; 简单来说就是通过你的邻居的“类别”&#xff0c;来推测你的“类别” 定义&#xff1a;如果一个样本在特征空间中的k个最相似&#xff08;即特征空间中最临近&#xff09;的样本中大多数属于某一类别&#xff0c;则该样本也属于这个类别。 2.…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023