【STL】红黑树的全面探索与红黑树的实现

news2024/11/15 2:02:50

ps：文章最后有完整的代码

1.红黑树的概念

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

2.红黑树的性质

1. 根节点⼀定是⿊⾊

2. ⼀条简单路径下不会出现连续的红⾊节点，如果⽗亲节点为红⾊，则其孩⼦节点⼀定为⿊⾊，如果⽗亲节点为⿊⾊，则没有限制

3. 对于每个节点来说，从该节点开始到其后代所有节点的简单路径上均包含相同数量的⿊⾊节点

4. （了解）每个空叶⼦结点都是⿊⾊的

在上图中，NIL 表示空叶⼦节点，以NIL 作为结束条件，⼀共有11 条路径，需要注意不是以叶⼦节点为结束条件（即不是7 条路径

满⾜上⾯的四个性质，红⿊树就可以保证其相对平衡的条件：红黑树可以保证最长路径会比最短路径的长度长出两倍。

最短路径：节点颜⾊为全⿊的路径，此时⿊⾊节点的个数即为路径的⻓度 最⻓路径：节点颜⾊为红⾊和⿊⾊交替出现的路径

3.红黑树的节点结构及定义

红黑树节点的定义通常包含以下几个关键部分：

3.1 基本元素

  • _left：指向节点的左子节点的指针
  • _right：指向节点的右子节点的指针
  • _parent：指向节点的父节点的指针
  • _kv：一个结构体或配对（pair），包含节点的键值（key）和值（value）。这取决于红黑的具体用途，可能只包含键或包含键值对。
  • _col：表示当前节点的颜色。

3.2 节点颜色（_col）

  • 在上面的定义中，_col 成员变量用于表示节点的颜色，通过 Color 枚举类型来定义，可以是 RED 或 BLACK。

3.3 构造函数

  • 初始化一个新节点时，通常需要一个构造函数，它接受一个键值对（或仅键），并设置节点的左子节点、右子节点、父节点和颜色（初始化为红色）

3.4BR节点定义：

template<class K, class V>
struct BSTreeNode
{
	BSTreeNode<K, V>* _left;    //左子树
	BSTreeNode<K, V>* _right;   //右子树
	BSTreeNode<K, V>* _parent;  //父亲
	pair<K, V> _kv;       //存放节点值的
	string _col;    //颜色（通过这个可以直到左右子树存在情况）
 
	//构造函数
	BSTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _col("RED")     //默认颜色为红色
	{}
};

红黑树的节点结构与二叉搜索树和AVL树差别不大，最大的差别就是加入了一个新的存储点——颜色

4.红⿊树的性质与平衡控制关系

因为⿊⾊节点的个数可以决定⼀条路径的⻓度，假设⿊⾊节点的个数为 h ，则最短路径的⻓度也为 h ，满⾜第⼆条规则时，红⾊节点的 个数不会超过⿊⾊节点（ 1 个或者 h 个），从⽽最⻓路径的最⼤⻓度为 2h ，因为红⾊节点是在⿊⾊节点出现后才会出现。

如果按照下图的插⼊⽅式导致红⾊节点连续出现

违反了规则⼆，此时最短路径的⻓度的两倍会⼩于最⻓路径的⻓度，从⽽打破了红⿊树的平衡。

如果插⼊的 27 为⿊⾊节点，则最⻓路径的⻓度增加，并且⿊⾊节点的个数也增加，违反了规则三，此时对于其他路径来说也需要增加 ⼀个⿊⾊节点。

所以为了维持平衡，不可以插⼊⿊⾊节点，此时最⻓路径的⻓度刚好为 2h ，如下图所示：

综上所述，在满⾜第⼆条规则和第三条规则下可以保证红⿊树的最⻓路径始终不会超过最短路径的 2 倍

5.红黑树的插入

根据红⿊树的性质可以看出红⿊树如何控制⾼度近似平衡，但是如果插⼊了节点，可能会破坏原有的平衡，此时需要通过重新填⾊或 者旋转调整使红⿊树重新达到平衡

在前⾯的分析中可以得知，如果插⼊的节点是⿊⾊节点，可能会导致每⼀条路径都需要多⼀个⿊⾊节点，为了更加⽅便处理，规定插 入的节点是红色节点

情况1 ：不需要调整

如果插⼊的节点是红色节点，并且其⽗亲节点是黑色节点，此时不需要进⾏任何处理，当⽗亲节点是⿊⾊节点时，保证了规则三没有 违背，因为⿊⾊节点的个数决定了⾼度，插⼊前如果保证原树是红⿊树，那么⾼度⼀定满⾜红⿊树的近似平衡，并且此时插⼊红⾊节 点也不会违背规则⼆，如下图的⼀种情况所示：

情况2 ： uncle 节点为红⾊

如果 cur 的节点是红⾊，并且其⽗亲节点（假设为 parent ）是红⾊节点，此时说明⽗亲的兄弟节点（假设为 uncle ）也⼀定为红⾊， 因为插⼊前⼀定是红⿊树（插⼊前不是红⿊树那么插⼊前就已经出现了不平衡，需要进⾏调整），当⽗亲节点时红⾊，说明⽗亲节点 所在的路径缺少⿊⾊节点，违反了规则三。⽗亲节点的⽗亲节点（假设为 grandfather ）也⼀定为⿊⾊，如果为红⾊则违反了第⼆条 规则所以插⼊前的状态应该为：

cur 节点可能为新增的红⾊节点，也可能为上⼀次调整变为的红⾊节点

1. 假设 a 、 b 、 c 、 d 和 e 为⿊⾊节点个数为 0 的红⿊树，此时 cur 为新插⼊节点如下图所示：

因为出现了连续的红⾊节点，为了恢复红⿊树的平衡，此时需要进⾏调整，因为 uncle 节点为红⾊，为了保证每条路径上都有⼀ 个⿊⾊节点并且保证没有连续的红⾊节点出现，将 parent 节点的颜⾊改为⿊⾊，将 uncle 节点的颜⾊改为⿊⾊，将 节点改为红⾊（如果 grandfather 节点为根节点则再处理为⿊⾊），处理完后， cur = grandfather 继续向上调整直到遇到根节 点：

2、假设 a 、 b 、 c 、 d 和 e 为⿊⾊节点个数⼤于 0 ，此时 cur 为上⼀次调整变成的红⾊节点，如下图所示：

对于当前情况来说，只有 cur 位置的节点是红⾊，其余⼏棵⼦树已经通过调整变成了符合规则的红⿊树，所以也可以归类为上⾯ 的情形，处理⽅式与上⾯相同

情况3 ： uncle 节点为⿊⾊

uncle 节点为⿊⾊时⼀共有两种情况：

1. uncle 节点不存在

2. uncle 节点存在且为⿊

因为红⿊树规定下空节点是⿊⾊的，所以 析，对于 uncle 节点不存在与存在且为⿊可以视为⼀种情况，下⾯主要以 uncle 节点不存在进⾏分 uncle 节点存在且为⿊的情况给出⼀种分析，剩下与 uncle 节点不存在的情况类似

当 cur 节点在 parent 的左⼦树并且 parent 在 grandfather 的左⼦树时，此时需要进⾏右单旋，将 parent 的颜⾊更新为⿊⾊，grandfather 的颜⾊更新为红⾊，原因类⽐左单旋，过程如下图所示：

当 cur 节点在 parent 的右⼦树并且 parent 在grandfather 的左⼦树时，此时需要进⾏左右双旋，将 cur 的颜⾊更新为⿊⾊，将grandfather 的颜⾊更新为红⾊，过程如下：

当 cur 节点在 parent 的左⼦树并且 parent 在grandfather 的右⼦树时，此时需要进⾏右左双旋，将 cur 的颜⾊更新为⿊⾊，将grandfather 的颜⾊更新为红⾊，过程如下：

如果 un cle 节点本身存在，那么经过 uncle 节点的路径下⽅的两个⼦树为红⾊，而parent 插⼊节点前⾄少会有⼀个⿊⾊节点，如下图：

此时在 parent 的右侧插⼊⼀个 cur 节点（本身就是红⾊节点 cur 节点也是如此）如下：

此时如果只是对 parent 节点的颜⾊进⾏改变，则会出现 parent 所在路径⽐uncle 所在路径多⼀个⿊⾊节点，所以为了解决这个问题，单单改变颜⾊⽆法解决，当 cur在parent 的右边时，只需要⼀次左单旋即可，⽽ cur 在 parent 的左边时，需要先进⾏右旋再进⾏左旋，以右左双旋为例，如下图所示：

6、检测红黑树是否造到破坏代码演示(C++)：

while (parent && parent->_col == RED) //当父亲节点为红色，则出现了连续的红色，不符合条件
		{
			Node* grandfather = parent->_parent;
			//    g
			//  p   u
			if (parent == grandfather->_left) {	
				Node* uncle = grandfather->_right;
				if (uncle && uncle->_col == RED) //叔叔存在并且为红
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
 
					cur = grandfather;
					parent = cur->_parent; //往上面走
				}
				else
				{
					//u存在且为黑或不存在 ->变色再继续往上处理 + 变色
					if (cur == parent->_left) { //cur存在那么cur一定为红色 
 
						//    g
						//  p   u
						//c
						//单旋，把p旋转上去，p作为子树根节点，g作为p的右
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//    g
						//  p   u
						//    c
						//双旋，将cur旋转上去，p作为cur的左，然后再旋转把cur旋转上去，g作为cur右边
						RotateL(parent);
						RotateR(grandfather);
 
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
			else
			{
				//    g
				//  u   p
				Node* uncle = grandfather->_left;
				// 叔叔存在且为红，-》变色即可
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
 
					// 继续往上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else // 叔叔不存在，或者存在且为黑
				{
					// 情况二：叔叔不存在或者存在且为黑
					// 旋转+变色
					//      g
					//   u     p
					//            c
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//		g
						//   u     p
						//      c
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
		}

7.红黑树的验证

  • 检测其是否满足二叉搜索树(中序遍历是否为有序序列)
  • 检测其是否满足红黑树的性质
  • 中序遍历的代码演示
void InOrder()
{
	_InOrder(_root);
	cout << endl;
}
void _InOrder(Node* root)
{
	if (root == nullptr) return;
	_InOrder(root->_left);
	_cout << root->_kv.first << ":" << root->_kv.second << endl;
	_InOrder(root->_right);
}

检测其是否满足红黑树的性质(C++)

bool IsBalance()
{
    if (_root == nullptr)
        return true;
 
    if (_root->_col == RED)
    {
        return false;
    }
 
    // 随便找条路径作为参考值
    int refNum = 0;
    Node* cur = _root;
    while (cur)
    {
        if (cur->_col == BLACK)
        {
            ++refNum;
        }
        cur = cur->_left;
    }
 
    return Check(_root, 0, refNum);
}
 
 
bool Check(Node* root, int blackNum, const int refNum)
{
    if (root == nullptr)
    {
        //cout << blackNum << endl;
        if (refNum != blackNum)
        {
            cout << "存在黑色节点的数量不相等的路径" << endl;
            return false;
        }
        return true;
    }
 
    if (root->_col == RED && root->_parent->_col == RED)
    {
        cout << root->_kv.first << "存在连续的红色节点" << endl;
        return false;
    }
 
    if (root->_col == BLACK)
    {
        blackNum++;
    }
 
    return Check(root->_left, blackNum, refNum)
        && Check(root->_right, blackNum, refNum);
}

8.完整代码

#include<iostream>
#include<vector>
#include<assert.h>
using namespace std;
 
enum Colour
{
	RED,
	BLACK
};
 
template<class K, class V>
struct RBTreeNode
{
	pair<K, V> _kv;
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;
	Colour _col;
 
	RBTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
	{}
};
 
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);
	}
 
	RBTree<K, V>& operator=(RBTree<K, V> t)
	{
		swap(_root, t._root);
		return *this;
	}
 
	~RBTree()
	{
		Destroy(_root);
		_root = nullptr;
	}
 
	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)
		{
			parent = cur;
			if (cur->_kv.first < kv.first) cur = cur->_right;
			else if (cur->_kv.first > kv.first) cur = cur->_left;
			else return false;
		}
 
		cur = new Node(kv);
		// 新增节点。颜色红色给红色
		cur->_col = RED;
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;
 
		while (parent && parent->_col == RED) //当父亲节点为红色，则出现了连续的红色，不符合条件
		{
			Node* grandfather = parent->_parent;
			//    g
			//  p   u
			if (parent == grandfather->_left) {
				Node* uncle = grandfather->_right;
				if (uncle && uncle->_col == RED) //叔叔存在并且为红
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
 
					cur = grandfather;
					parent = cur->_parent; //往上面走
				}
				else
				{
					//u存在且为黑或不存在 ->变色再继续往上处理 + 变色
					if (cur == parent->_left) { //cur存在那么cur一定为红色 
 
						//    g
						//  p   u
						//c
						//单旋，把p旋转上去，p作为子树根节点，g作为p的右
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//    g
						//  p   u
						//    c
						//双旋，将cur旋转上去，p作为cur的左，然后再旋转把cur旋转上去，g作为cur右边
						RotateL(parent);
						RotateR(grandfather);
 
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
			else
			{
				//    g
				//  u   p
				Node* uncle = grandfather->_left;
				// 叔叔存在且为红，-》变色即可
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
 
					// 继续往上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else // 叔叔不存在，或者存在且为黑
				{
					// 情况二：叔叔不存在或者存在且为黑
					// 旋转+变色
					//      g
					//   u     p
					//            c
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//		g
						//   u     p
						//      c
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
		}
 
		_root->_col = BLACK; //无论什么情况根节点都为黑
 
		return true;
	}
 
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
 
	int Height()
	{
		return _Height(_root);
	}
 
	int Size()
	{
		return _Size(_root);
	}
 
	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}
 
		return nullptr;
	}
 
	bool IsBalance()
	{
		if (_root == nullptr)
			return true;
 
		if (_root->_col == RED)
		{
			return false;
		}
 
		// 随便找条路径作为参考值
		int refNum = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				++refNum;
			}
			cur = cur->_left;
		}
 
		return Check(_root, 0, refNum);
	}
 
 
private:
	bool Check(Node* root, int blackNum, const int refNum)
	{
		if (root == nullptr)
		{
			//cout << blackNum << endl;
			if (refNum != blackNum)
			{
				cout << "存在黑色节点的数量不相等的路径" << endl;
				return false;
			}
			return true;
		}
 
		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << root->_kv.first << "存在连续的红色节点" << endl;
			return false;
		}
 
		if (root->_col == BLACK)
		{
			blackNum++;
		}
 
		return Check(root->_left, blackNum, refNum)
			&& Check(root->_right, blackNum, refNum);
	}
 
 
	int _Size(Node* root)
	{
		return root == nullptr ? 0 : _Size(root->_left) + _Size(root->_right) + 1;
	}
 
	int _Height(Node* root)
	{
		if (root == nullptr)
			return 0;
 
		int leftHeight = _Height(root->_left);
		int rightHeight = _Height(root->_right);
 
		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
	}
 
	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)
	{
		_rotateNum++;
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
 
		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;
 
		Node* parentParent = parent->_parent;
 
		subR->_left = parent;
		parent->_parent = subR;
 
		if (parentParent == nullptr)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (parent == parentParent->_left)
			{
				parentParent->_left = subR;
			}
			else
			{
				parentParent->_right = subR;
			}
 
			subR->_parent = parentParent;
		}
	}
 
	void  RotateR(Node* parent)
	{
		_rotateNum++;
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
 
		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;
 
		Node* parentParent = parent->_parent;
 
		subL->_right = parent;
		parent->_parent = subL;
 
		if (parentParent == nullptr)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (parent == parentParent->_left)
			{
				parentParent->_left = subL;
			}
			else
			{
				parentParent->_right = subL;
			}
 
			subL->_parent = parentParent;
		}
	}
 
	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* newRoot = new Node(root->_kv);
		newRoot->_left = Copy(root->_left);
		newRoot->_right = Copy(root->_right);
 
		return newRoot;
	}
 
private:
	Node* _root = nullptr;
 
public:
	int _rotateNum = 0;
};
 
 
 
void TestRBTree1()
{
	RBTree<int, int> t;
	//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	for (auto e : a)
	{
		t.Insert({ e, e });
	}
 
	t.InOrder();
	cout << t.IsBalance() << endl;
}

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

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

相关文章

如何使用IDEA搭建Mybatis框架环境

如何使用IDEA搭建Mybatis框架环境

文章目录 ☕前言为什么学习框架技术Mybatis框架简介 &#x1f379;一、如何配置Mybatis框架环境1.1下载需要MyBatis的jar文件1.2部署jar文件1.3创建MyBatis核心配置文件configuration.xml1.4.创建持久类(POJO)和SQL映射文件1.5.创建测试类 &#x1f9cb;二、 MyBatis框架的优缺…
阅读更多...
前端性能优化：使用Vue3+TS+Canvas对图片进行压缩后再上传，优化带宽，减小服务器存储成本，减少流量损耗

前端性能优化：使用Vue3+TS+Canvas对图片进行压缩后再上传，优化带宽，减小服务器存储成本，减少流量损耗

在上传图片之前&#xff0c;对图片进行压缩。看到这里是不是有点懵&#xff0c;前端怎么压缩图片呢&#xff0c;这不应该是后端做的吗&#xff1f; 但是我在开发的时候接到了这样一个需求&#xff0c;要求对用户上传的图片进行一定的压缩&#xff0c;而且并且尽量还原图片的清…
阅读更多...
大模型如何改变世界？李彦宏：未来至少一半人要学会“提问题“

大模型如何改变世界？李彦宏：未来至少一半人要学会“提问题“

2023年爆火的大模型&#xff0c;对我们来说意味着什么&#xff1f; 百度创始人、董事长兼CEO李彦宏认为&#xff0c;“大模型即将改变世界。” 5月26日&#xff0c;李彦宏参加了在北京举办的2023中关村论坛&#xff0c;发表了题为《大模型改变世界》的演讲。李彦宏认为&#…
阅读更多...
2024年新算法-基于SBOA-BP混合神经网络的数据预测(Python代码实现)

2024年新算法-基于SBOA-BP混合神经网络的数据预测(Python代码实现)

在今天的数字化时代&#xff0c;机器学习和人工智能领域的不断发展为数据处理和预测提供了强大的工具。其中&#xff0c;BP神经网络&#xff08;反向传播神经网络&#xff09;作为一种经典的网络模型&#xff0c;因其能够处理复杂的非线性问题而备受关注。然而&#xff0c;传统…
阅读更多...
吴恩达机器学习课后作业-07kmeans and pca

吴恩达机器学习课后作业-07kmeans and pca

k-均值与PCA k-均值图片颜色聚类 PCA&#xff08;主成分分析&#xff09;对x去均值化图像降维 k-均值 K-均值是最普及的聚类算法&#xff0c;算法接受一个未标记的数据集&#xff0c;然后将数据聚类成不同的组。 K-均值是一个迭代算法&#xff0c;假设我们想要将数据聚类成n个…
阅读更多...
python-变量声明、数据类型、标识符

python-变量声明、数据类型、标识符

一.变量 1.什么是变量 为什么需要变量呢&#xff1f; 一个程序就是一个世界&#xff0c;不论使用哪种高级程序语言编写代码&#xff0c;变量都是其程序的基本组成单位。如下图所示的sum和sub都是变量。 变量的定义&#xff1a; 变量相当于内存中一个数据存储空间的表示&#…
阅读更多...
Spring MVC常用注解及用法

Spring MVC常用注解及用法

目录 1.建立连接--RequestMapping 2.请求 2.1 传递单个参数 2.2 传递多个参数 2.3 传递对象 2.4 参数重命名--RequestParam 2.5 传递数组 2.6 传递集合 2.7 传递json数据--RequestBody 2.8 获取URL中参数--PathVariable 2.9 上传文件--RequestPart 2.10 获取Cookie--…
阅读更多...
bomb 实验

bomb 实验

GDB常用命令&#xff1a; GDB调试常用命令-CSDN博客 原理&#xff1a; 编译与反汇编过程-CSDN博客 Bomb实验实现 阶段一&#xff1a; 分析 分配空间&#xff1a;sub $0x8,%rsp 为局部变量分配栈空间。设置参数&#xff1a;mov $0x402400,%esi 将字符串地址加载到 %esi。…
阅读更多...
MMsegmentation与MMdeploy简单使用

MMsegmentation与MMdeploy简单使用

最近涉及到了图像分割的任务&#xff0c;于是拿来写下博客加深下使用。 MMsegmentation与MMdeploy的环境配置暂不做讲解&#xff0c;在官网和其他博客中有很多说明。 MMdeploy主要是把pt转为 onnx_int8的情况。 MMsegmentation环境配置可以参考 : 安装与配置MMSegmentation 目录…
阅读更多...
【管理型文档】软件需求管理过程（原件）

【管理型文档】软件需求管理过程（原件）

软件需求管理规程应明确需求收集、分析、确认、变更控制及验证等流程&#xff0c;确保需求准确反映用户期望&#xff0c;支撑软件开发。该规程要求系统记录需求来源&#xff0c;通过评审确保需求完整、清晰、无歧义&#xff0c;实施变更控制以维护需求基线稳定&#xff0c;并持…
阅读更多...
后端面试真题整理

后端面试真题整理

面试问题整理 本人主要记录2024年秋招、春招过程中的疑难八股真题&#xff0c;参考来源&#xff1a;牛客网、知乎等。 八股 深拷贝与浅拷贝 浅拷贝&#xff1a; 浅拷贝会在堆上创建一个新的对象&#xff08;区别于引用拷贝的一点&#xff09;&#xff0c;不过&#xff0c;如果…
阅读更多...
井盖丢失隐患大?智慧井盖监管系统帮你解决

井盖丢失隐患大?智慧井盖监管系统帮你解决

在现代都市中&#xff0c;我们每天行走在钢筋水泥之间&#xff0c;却很少有人注意到脚下的小小井盖。这些不起眼的圆形铁盘不仅是城市地下管网的入口&#xff0c;更是维系城市生命线的重要组成部分。然而&#xff0c;当暴雨来袭&#xff0c;或是深夜无人之时&#xff0c;井盖的…
阅读更多...
无线麦克风什么牌子的音质效果好？一文读懂麦克风哪个牌子的好

无线麦克风什么牌子的音质效果好？一文读懂麦克风哪个牌子的好

无线领夹麦克风哪款音质最好&#xff1f;在这个追求高质量音效的年代&#xff0c;选择一款合适的无线领夹麦克风&#xff08;简称领夹麦&#xff09;对于提升录音或直播的音质至关重要。随着市场的不断扩大&#xff0c;市面上充斥着大量信号不稳定、音质差的无线领夹麦克风&…
阅读更多...
2024年汽车零部件企业CRM研究：服务商排名、案例分析、需求分析

2024年汽车零部件企业CRM研究：服务商排名、案例分析、需求分析

最近媒体上频现各车企大佬发声&#xff0c;抗议某汽车企业“不要卷价格&#xff0c;要卷长期价值”&#xff0c;还有的直接批判其打破行业规则。图穷匕现&#xff0c;汽车行业的竞争愈发激烈了。 汽车产业作为我国国民经济的重要支柱产业、经济增长和转型的重要抓手&#xff0…
阅读更多...
微软将持续多年的 Mono 项目移交给 Wine

微软将持续多年的 Mono 项目移交给 Wine

今天&#xff0c;微软突然决定将 Mono 项目交由 Wine 开发社区管理。自Mono项目上一次作为开源.NET框架发布以来&#xff0c;已经过去了五年时间&#xff0c;此前Wine已经使用了Mono的代码&#xff0c;而在微软专注于开源.NET和其他工作的情况下&#xff0c;此举是合理的&#…
阅读更多...
Python编程的终极十大工具（非常详细）零基础入门到精通，收藏这一篇就够了

Python编程的终极十大工具（非常详细）零基础入门到精通，收藏这一篇就够了

&#x1f91f; 基于入门网络安全打造的&#xff1a;&#x1f449;黑客&网络安全入门&进阶学习资源包 Python一直以来都是程序员们的首选编程语言之一&#xff0c;其灵活性和功能强大的库使其成为解决各种问题的理想选择。在本文中&#xff0c;我们将介绍Python编程的终…
阅读更多...
fdMemTable内存表进行SQL查询

fdMemTable内存表进行SQL查询

fdLocalSql可以对fdMemTable内存表进行SQL查询&#xff08;可以对多个fdMemTable内存表进行联表查询哦&#xff09;&#xff0c;fdLocalSql使用SQLITE引擎&#xff0c;而FIREDAC驱动SQLITE&#xff0c;连SQLITE驱动DLL都不需要附带的。 所有设置用FormCreate里用代码 procedure…
阅读更多...
【C#】Visual Studio2017 MSDN离线安装

【C#】Visual Studio2017 MSDN离线安装

1. 运行Visual Studio Installer 在Windows的开始菜单中直接搜索 2. 单击“修改”按钮 3. 依次点击&#xff0c;单个组件 - 代码工具 - Help Viewer - 修改&#xff0c;开始安装 4. 下载速度慢解决方法 修改IPv4 DNS 参考&#xff1a;visual studio下载慢解决方法&#xf…
阅读更多...
unity脚本

unity脚本

Transform.Rotate 描述 使用 Transform.Rotate 以各种方式旋转 GameObjects。通常以欧拉角而不是四元数提供旋转。 可以在世界轴或本地轴中指定旋转。 世界轴旋转使用 Scene 的坐标系&#xff0c;因此在开始旋转 GameObject 时&#xff0c;它的 x、y 和 z 轴与 x、y 和 z 世…
阅读更多...
Leetcode 131.分割回文串 回溯 C++实现

Leetcode 131.分割回文串 回溯 C++实现

Leetcode 131. 分割回文串 问题&#xff1a;给你一个字符串 s&#xff0c;请你将 s 分割成一些子串&#xff0c;使每个子串都是 回文串 。返回 s 所有可能的分割方案。 算法&#xff1a; 创建二维返回数组 ans &#xff0c;和临时数组 path 。 进入 dfs 函数&#xff0c;当 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023