【C++】map和set的封装

news2024/12/23 9:01:59

文章目录

    • 一、前情回顾
    • 二、简化源码
    • 三、仿函数
    • 四、迭代器
    • 五、set的实现
    • 六、map的实现
    • 七、红黑树代码

一、前情回顾

set 参数只有 key，但是map除了key还有value。我们还是需要KV模型的红黑树的：

#pragma once
#include <iostream>
#include <assert.h>
#include <time.h>
using namespace std;
enum Color
{
	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;

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

template<class K,class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
	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 (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(kv);
		cur->_col = RED;
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}

		while (parent && parent->_col == RED)
		{
			Node* grandfater = parent->_parent;
			if (parent == grandfater->_left)
			{
				Node* uncle = grandfater->_right;
				//情况一：u存在且为红
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfater->_col = RED;
					//向上调整
					cur = grandfater;
					parent = cur->_parent;
				}
				else
				{
					//情况2
					if (cur == parent->_left)
					{
						RotateR(grandfater);
						parent->_col = BLACK;
						grandfater->_col = RED;
					}
					//情况3
					else
					{
						//       g
						//  p
						//    c 
						RotateL(parent);
						RotateR(grandfater);
						cur->_col = BLACK;
						grandfater->_col = RED;
					}
					break;
				}
			}
			else//parent==grandfater->_right
			{
				Node* uncle = grandfater->_left;
				//情况1：u存在且为红色
				if (uncle && uncle->_col == RED)
				{
					uncle->_col = parent->_col = BLACK;
					grandfater->_col = RED;
					//向上调整
					cur = grandfater;
					parent = cur->_parent;
				}
				else
				{
					//情况2：u不存在/u存在为黑色
					//g
					//    p
					//        c
					if (cur == parent->_right)
					{
						RotateL(grandfater);
						grandfater->_col = RED;
						parent->_col = BLACK;
					}
					//情况3
					//     g
					 //         p
					 //      c
					else
					{
						RotateR(parent);
						RotateL(grandfater);
						cur->_col = BLACK;
						grandfater->_col = RED;
					}
					break;
				}

			}
		}
		//根变黑
		_root->_col = BLACK;
		return true;
	}

	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 (ppNode == nullptr)
		{
			_root = subR;
			_root->_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;
		parent->_parent = subL;
		subL->_right = parent;
		if (ppNode == nullptr)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}
	}


	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);
	}


	bool Check(Node*root,int blackNum,int ref)
	{
		if (root == nullptr)
		{
			//cout << blackNum << endl;
			if (blackNum != ref)
			{
				cout << "违反规则：本条路径的黑色结点的数量根最左路径不相等" << endl;
				return false;
			}
			return true;
		}
		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << "违反规则：出现连续的红色结点" << endl;
			return false;
		}
		if (root->_col == BLACK)
		{
			++blackNum;
		}
		return Check(root->_left,blackNum,ref)
			&& Check(root->_right,blackNum,ref);
	}

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

		if (_root->_col != BLACK)
		{
			return false;
		}
		int ref = 0;
		Node* left = _root;
		while (left)
		{
			if (left->_col == BLACK)
			{
				++ref;
			}
			left = left->_left;
		}
		return Check(_root,0,ref);
	}
private:
	Node* _root = nullptr;
};

二、简化源码

翻开源码一看📕

RBTree的结构源码：是KV结构的红黑树

RBTree是通过传入的Value的值来判断类型，也就是一棵泛型的RBTree，通过不同的实例化，实现出了Map和Set：

对于map:传key，对于set:传pair

map的结构简化源码：

image-20230216171130319

set的结构简化源码：

image-20230216171212456

为了让我们的红黑树能够识别set与map我们增加一个模板参数T：

template<class K, class T>
class RBTree

对于T模板参数可能是键值Key，也可能是由Key和Value共同构成的键值对。

如果是set容器，那么它传入底层红黑树的模板参数就是Key和Key：

template<class K>
class set
{
  private:
    RBTree<K,K> _t;
};

如果是map容器，传入底层红黑树的模板参数就是Key和Key和value的键值对：

class map
{
private:
    RBTree<K, pair<const K,V>> _t;
};

通过上面，我们可以知道，对于set和map的区别：我们只要通过第二个模板参数就能进行区分，那是不是第一个模板参数就没有意义了呢？

对于insert(const Value&v)来说，需要放入存入的值，确实是这个样子的，插入的值是value，对于set就是key，对于map就是pair。

但是对于find(const Key&key)来说，查找的参数不是value，找的不是pair而是Key，对于map容器来说就不行了。

**红黑树的节点**：set容器：K和T都是键值Key; map容器：K是键值Key，T由Key和Value构成的键值对；但是底层红黑树并不知道上层容器到底是map还是set，因此红黑树的结点当中直接存储T就行了，如果是set的时候，结点当中存储的是键值Key；如果是map的时候，结点当中存储的就是键值对,所以红黑树的结点定义如下,由T类型来决定红黑树存的是key还是pair：

template<class T>
    //三叉链结构
struct RBTreeNode
{
	T _data;
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;

	Color _col;
	RBTreeNode(const T& data)
		:_data(data)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _col(RED)
	{}
};

三、仿函数

这里存在一个问题📝：插入的时候data的大小如何去进行比较：我们并不知道是什么类型是key，还是pair的比较，而我们刚开始kv结构就直接用kv.first去比较了。

对于set是Key，可以比较

对于map是pair，那我们要取其中的first来比较，但是pair的大小并不是直接按照first去进行比较的，而我们只需要按照first去进行比较

由于底层的红黑树不知道传的是map还是set容器，当需要进行两个结点键值的比较时，底层红黑树传入的仿函数来获取键值Key，进行两个结点键值的比较：这个时候我们就需要仿函数了，如果是set那就是用于返回T当中的键值Key,如果是map那就是用于返回pair的first：

仿函数/函数对象也是类，是一个类对象。仿函数要重载operator()。

namespace HWC
{
	template<class K,class V>
	class map
	{
		struct  MapKeyOfT
		{
			const K& operator()(const pair<const K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
	private:
		RBTree<K, pair<const K,V>,MapKeyOfT> _t;
	};

namespace HWC
{
	template<class K>
	class set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	private:
		RBTree<K,K,SetKeyOfT> _t;
	};

博主画了个图更加容易进行比对👇

image-20230216191436991

查找过程，此时就可以套上我们所写的仿函数对象去进行数据的大小比较了：

        KeyOfT kot;//仿函数对象
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (kot(cur->_data)<kot(data))
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (kot(cur->_data)>kot(data))
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

四、迭代器

红黑树的正向迭代器是对结点指针进行了封装，所以这里的正向迭代器就只有一个成员变量：结点的指针，并没有什么其他的地方，迭代器的定义：

template<class T,class Ref,class Ptr>
struct __RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef __RBTreeIterator<T,Ref,Ptr> Self;
	typedef __RBTreeIterator<T, T&, T*> iterator;
	Node* _node;

	__RBTreeIterator(Node*node)
		:_node(node)
	{}

	//普通迭代器的时候，它是拷贝构造
	//const迭代器的时候，它是构造，支持用普通迭代器构造const迭代器
	__RBTreeIterator(const iterator& s)
		:_node(s._node)
	{}
}

*:解引用操作，返回对应结点数据的引用:

Ref operator*()
	{
		return _node->_data;
	}

->:成员访问操作符,返回结点数据的引用：

Ptr operator->()
	{
		return &_node->_data;
	}

!=、==:比较简单

  bool operator !=(const Self & s) const
	{
		return _node != s._node;
	}
	bool operator ==(const Self& s) const
	{
		return _node == s._node;
	}

这里的迭代器重点是迭代器的++:

一个结点的正向迭代器进行++操作后，根据红黑树中序(左、根、右)找到当前结点的下一个结点，中序的第一个节点是最左，迭代器的++怎么去找：

如果节点的右子树不为空，++就是找右子树的最左节点

如果节点的右子树为空，++就是找祖先（孩子是父亲的左的那个祖先）

代码实现✍：

	Self& operator++()
	{
		if (_node->_right)
		{
			Node* min = _node->_right;
			while (min->_left)
			{
				min = min->_left;
			}
			_node = min;
		}
		else
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == parent->_right)
			{
				cur = cur->_parent;
				parent = parent->_parent;
			}
			_node = parent;
		}
		return *this;
	}

迭代器的--

对于–，如果是根，–就是左子树，找到左子树最大的那一个（最右节点）

如果节点的左子树不为空，--找左子树最右的节点

如果节点的左子树为空，--找祖先（孩子是父亲的右的祖先）

代码实现✍：

Self& operator--()
	{
		if (_node->_left)
		{
			Node* max = _node->_left;
			while (max->_right)
			{
				max = max->_right;
			}
			_node = max;
		}
		else
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent&&cur==parent->_left)
			{
				cur = cur->_parent;
				parent = parent->_parent;
			}
			_node = parent;
		}
		return *this;
	}

不要忘记迭代器的两个核心成员：begin()与end()

begin()：返回中序（左、根、右）第一个结点的正向迭代器，即最左节点，返回的是最左节点,直接找最左节点即可

end()：返回中序（左、根、右）最后一个结点下一个位置的正向迭代器，这里直接用空指针

template<class K, class T,class KeyOfT>
class RBTree
{
	typedef RBTreeNode<T> Node;
public:
	typedef __RBTreeIterator<T> iterator;

	iterator begin()
	{
		Node* left = _root;
		while (left && left->_left)
		{
			left = left->_left;
		}
		return iterator(left);
	}

	iterator end()
	{
		return iterator(nullptr);
	}
}

五、set的实现

通过前面底层红黑树的接口进行套用即可实现set的实现：

值得注意的是🔴：typename:没有实例化的模板，区分不了是静态变量还是类型，typename告诉编译器是类型

#pragma once
#include "RBTree.h"

namespace hwc
{
	template <class K>
	class set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}

		};
	public:
        //typename:没有实例化的模板，区分不了是静态变量还是类型，typename告诉编译器是类型
		typedef typename RBTree<K, K, SetKeyOfT>::const_iterator iterator;//key不可以修改
		typedef typename RBTree<K, K, SetKeyOfT>::const_iterator const_iterator;

		iterator begin() const 
		{
			return _t.begin();
		}

		iterator end() const 
		{
			return _t.end();
		}
        
		pair<iterator,bool> insert(const K& key)
		{
            //底层红黑树的iterator是普通迭代器
			pair<typename RBTree<K, K, SetKeyOfT>::iterator, bool> ret =  _t.Insert(key);
			return pair<iterator, bool>(ret.first, ret.second);//用普通迭代器构造const迭代器
		}
	private:
		RBTree<K, K,SetKeyOfT> _t;
	};

	void test_set()
	{
		int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
		set<int> s;
		for (auto e : a)
		{
			s.insert(e);
		}

		set<int>::iterator it = s.begin();
		while (it != s.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;

		for (auto e : s)
		{
			cout << e << " ";
		}
		cout << endl;
	}
}

六、map的实现

同样是套用上底层红黑树的接口，不过map的实现有一个很重要的地方，那就是[]的实现

#pragma once
#include "RBTree.h"
namespace hwc
{
	template<class K,class V>
	class map
	{
		struct MapkeyOfT
		{
			const K& operator()(const pair<const K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		//typename:没有实例化的模板，区分不了是静态变量还是类型，typename告诉编译器是类型
		typedef typename RBTree<K, pair<const K, V>, MapkeyOfT>::iterator iterator;
		typedef typename RBTree<K, pair<const K, V>, MapkeyOfT>::const_iterator 
			const_iterator;

		iterator begin()
		{
			return _t.begin();
		}
		iterator end()
		{
			return _t.end();
		}

		const_iterator begin() const
		{
			return _t.begin();
		}
		const_iterator end() const
		{
			return _t.end();
		}
		pair<iterator,bool> insert(const pair<const K, V>& kv)
		{
			return _t.Insert(kv);
		}

		V& operator[](const K& key)
		{
			pair<iterator, bool> ret = insert(make_pair(key, V()));
			return ret.first->second;
		}
	private:
		RBTree<K, pair<const K, V>, MapkeyOfT> _t;
	};


	void test_map()
	{
		int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
		map<int, int> m;
		for (auto e : a)
		{
			m.insert(make_pair(e, e));
		}

		map<int, int>::iterator it = m.begin();
		while(it!=m.end())
		{
			it->second++;
			cout << it->first << ":" << it->second << endl;
			++it;
		}
		cout << endl;

		map<string, int> countMap;
		string arr[] = { "苹果","西瓜","香蕉","苹果"};
		for (auto& e : arr)
		{
			countMap[e]++;
		}

		for (auto& kv : countMap)
		{
			cout << kv.first << ":" << kv.second << endl;
		}
	}
}

七、红黑树代码

最后，在这里送上源码：

#pragma once

#pragma once
#include <iostream>
#include <assert.h>
#include <time.h>
using namespace std;
enum Color
{
	RED,
	BLACK,
};
template<class T>
struct RBTreeNode
{
	T _data;
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;

	Color _col;
	RBTreeNode(const T& data)
		:_data(data)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _col(RED)
	{}
};

template<class T,class Ref,class Ptr>
struct __RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef __RBTreeIterator<T,Ref,Ptr> Self;
	typedef __RBTreeIterator<T, T&, T*> iterator;
	Node* _node;

	__RBTreeIterator(Node*node)
		:_node(node)
	{}


	//普通迭代器的时候，它是拷贝构造
	//const迭代器的时候，它是构造，支持用普通迭代器构造const迭代器
	__RBTreeIterator(const iterator& s)
		:_node(s._node)
	{}

	Ref operator*()
	{
		return _node->_data;
	}
	Ptr operator->()
	{
		return &_node->_data;
	}

	Self& operator++()
	{
		if (_node->_right)
		{
			Node* min = _node->_right;
			while (min->_left)
			{
				min = min->_left;
			}
			_node = min;
		}
		else
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == parent->_right)
			{
				cur = cur->_parent;
				parent = parent->_parent;
			}
			_node = parent;
		}
		return *this;
	}

	Self& operator--()
	{
		if (_node->_left)
		{
			Node* max = _node->_left;
			while (max->_right)
			{
				max = max->_right;
			}
			_node = max;
		}
		else
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent&&cur==parent->_left)
			{
				cur = cur->_parent;
				parent = parent->_parent;
			}
			_node = parent;
		}
		return *this;
	}

	bool operator !=(const Self & s) const
	{
		return _node != s._node;
	}
	bool operator ==(const Self& s) const
	{
		return _node == s._node;
	}
};


template<class K, class T,class KeyOfT>
class RBTree
{
	typedef RBTreeNode<T> Node;
public:
	typedef __RBTreeIterator<T,T&,T*> iterator;
	typedef __RBTreeIterator<T,const T&,const T*> const_iterator;
	const_iterator begin() const 
	{
		Node* left = _root;
		while (left && left->_left)
		{
			left = left->_left;
		}
		return const_iterator(left);

	}
	const_iterator end() const 
	{
		return const_iterator(nullptr);
	}

	iterator begin()
	{
		Node* left = _root;
		while (left && left->_left)
		{
			left = left->_left;
		}
		return iterator(left);

	}
	iterator end()
	{
		return iterator(nullptr);
	}
	pair<iterator,bool> Insert(const T& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;
			return make_pair(iterator(_root),true);
		}
		KeyOfT kot;
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (kot(cur->_data) < kot(data))
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (kot(cur->_data) > kot(data))
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return make_pair(iterator(cur),false);
			}
		}
		cur = new Node(data);
		Node* newnode = cur;
		cur->_col = RED;
		if (kot(parent->_data) < kot(data))
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}

		while (parent && parent->_col == RED)
		{
			Node* grandfater = parent->_parent;
			if (parent == grandfater->_left)
			{
				Node* uncle = grandfater->_right;
				//情况一：u存在且为红
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfater->_col = RED;
					//向上调整
					cur = grandfater;
					parent = cur->_parent;
				}
				else
				{
					//情况2
					if (cur == parent->_left)
					{
						RotateR(grandfater);
						parent->_col = BLACK;
						grandfater->_col = RED;
					}
					//情况3
					else
					{
						//       g
						//  p
						//    c 
						RotateL(parent);
						RotateR(grandfater);
						cur->_col = BLACK;
						grandfater->_col = RED;
					}
					break;
				}
			}
			else//parent==grandfater->_right
			{
				Node* uncle = grandfater->_left;
				//情况1：u存在且为红色
				if (uncle && uncle->_col == RED)
				{
					uncle->_col = parent->_col = BLACK;
					grandfater->_col = RED;
					//向上调整
					cur = grandfater;
					parent = cur->_parent;
				}
				else
				{
					//情况2：u不存在/u存在为黑色
					//g
					//    p
					//        c
					if (cur == parent->_right)
					{
						RotateL(grandfater);
						grandfater->_col = RED;
						parent->_col = BLACK;
					}
					//情况3
					//     g
					 //         p
					 //      c
					else
					{
						RotateR(parent);
						RotateL(grandfater);
						cur->_col = BLACK;
						grandfater->_col = RED;
					}
					break;
				}

			}
		}
		//根变黑
		_root->_col = BLACK;
		return make_pair(iterator(newnode),true);
	}

	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 (ppNode == nullptr)
		{
			_root = subR;
			_root->_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;
		parent->_parent = subL;
		subL->_right = parent;
		if (ppNode == nullptr)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}
	}


	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);
	}


	bool Check(Node* root, int blackNum, int ref)
	{
		if (root == nullptr)
		{
			//cout << blackNum << endl;
			if (blackNum != ref)
			{
				cout << "违反规则：本条路径的黑色结点的数量根最左路径不相等" << endl;
				return false;
			}
			return true;
		}
		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << "违反规则：出现连续的红色结点" << endl;
			return false;
		}
		if (root->_col == BLACK)
		{
			++blackNum;
		}
		return Check(root->_left, blackNum, ref)
			&& Check(root->_right, blackNum, ref);
	}

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

		if (_root->_col != BLACK)
		{
			return false;
		}
		int ref = 0;
		Node* left = _root;
		while (left)
		{
			if (left->_col == BLACK)
			{
				++ref;
			}
			left = left->_left;
		}
		return Check(_root, 0, ref);
	}
private:
	Node* _root = nullptr;
};

本篇结束…

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

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

相关文章

游戏服务器算法-AOI基本介绍

游戏服务器算法-AOI基本介绍

一、直接比较所有对象 最直观也是最效率最低的一种方法。当一个事件发生&#xff0c;我们需要获得AOI范围以内的物体时&#xff0c;直接遍历游戏中所有的对象&#xff0c;并且进行坐标判断&#xff0c;如果小于或者等于AOI的范围&#xff0c;则为需要的游戏对象。 这种方法实…
阅读更多...
零基础小白如何学会云计算？

零基础小白如何学会云计算？

云计算作为新兴互联网技术&#xff0c;也是IT服务的集大成者&#xff0c;包括了基础硬件服务、平台服务、应用程序开发、系统架构等服务内容。云计算的出现承接了众多IT技术和其他行业的发展&#xff0c;比如大数据、人工智能以及工业、金融、医疗、物流等&#xff0c;是经济社…
阅读更多...
VBA提高篇_26 Textbox多行_ListBox_ComboBox

VBA提高篇_26 Textbox多行_ListBox_ComboBox

文章目录1. 文本框多行换行2. ListBox: 列表框2.1 列表框中添加条目的三种方法:3. ComboBox 组合框: 属性方法等同于以上ListBox1. 文本框多行换行 MultiLine: 控制文本框多行自动换行() Enterkeybehevior: True 代表允许在文本框中使用回车键换行 WordWrap: True 代表自动换…
阅读更多...
/etc/fstab文件

/etc/fstab文件

文件/etc/fstab存放的是系统中的文件系统信息&#xff0c;当系统启动的时候&#xff0c;系统会自动地从这个文件读取信息&#xff0c;并且会自动将此文件中指定的文件系统挂载到指定的目录。当正确的设置了该文件&#xff0c;则可以通过mount /directoryname命令来加载一个文件…
阅读更多...
Tapdata Connector 实用指南：数据入仓场景之数据实时同步到 BigQuery

Tapdata Connector 实用指南：数据入仓场景之数据实时同步到 BigQuery

【前言】作为中国的 “Fivetran/Airbyte”, Tapdata 是一个以低延迟数据移动为核心优势构建的现代数据平台&#xff0c;内置 60 数据连接器&#xff0c;拥有稳定的实时采集和传输能力、秒级响应的数据实时计算能力、稳定易用的数据实时服务能力&#xff0c;以及低代码可视化操作…
阅读更多...
恢复 iPhone 和 iPad 数据的 10 种简单工具

恢复 iPhone 和 iPad 数据的 10 种简单工具

它发生了.. 有时您需要从您的手机或平板设备恢复重要数据。 许多人已经开始将重要文件存储在手机上&#xff0c;因为他们几乎可以在任何情况下随时随地轻松访问数据。 从技术上讲&#xff0c;您会在几分之一秒内丢失所有存储的信息、照片、视频、音乐、文档等。因此&#xff…
阅读更多...
一文3000字用Postman从0到1实现UI自动化测试

一文3000字用Postman从0到1实现UI自动化测试

“阅读本文大概需要4分钟。Postman不是做接口测试的吗&#xff1f;为什么还能做UI自动化测试呢&#xff1f; 其实&#xff0c;只要你了解Selenium的运行原理&#xff0c;就可以理解为什么Postman也能实现UI自动化测试了。 Selenium底层原理 运行代码&#xff0c;启动浏览器后…
阅读更多...
笔试题（十六）：计算矩阵面积

笔试题（十六）：计算矩阵面积

# 我们给出了一个&#xff08;轴对齐的&#xff09;二维矩形列表 rectangles。 # 对于 rectangle[i] [xi1, yi1, xi2, yi2]&#xff0c;表示第i个矩形的坐标&#xff0c; # (xi1, yi1)是该矩形左下角的坐标&#xff0c; (xi2, yi2)是该矩形右上角的坐标。 # 计算平面中所有 r…
阅读更多...
CAJ论文怎么批量免费转换成Word

CAJ论文怎么批量免费转换成Word

大家都知道CAJ文件吗&#xff1f;这是中国学术期刊数据库中的文件&#xff0c;这种文件类型比较特殊。如果想要提取其中的内容使用&#xff0c;该如何操作呢&#xff1f;大家可以试试下面这种免费的caj转word的方法,多个文档也可以一起批量转换。准备材料&#xff1a;CAJ文档、…
阅读更多...
信息系统项目管理师知识点汇总（2023最新）

信息系统项目管理师知识点汇总（2023最新）

信息系统项目管理师 信息系统项目管理师简介如何应对考试考试细节与学习 十大管理 十大管理四十七过程 信息化和信息系统 项目管理基础 项目整体管理 项目范围管理 项目进度管理 项目成本管理 项目质量管理 项目人力资源管理 项目沟通管理 项目干系人管理 项目风险…
阅读更多...
pytest数据驱动

pytest数据驱动

文章目录一、数据驱动概念二、数据驱动yaml1、yaml的基本语法&#xff1a;2、yaml支持的数据格式&#xff1a;3、安装4、使用5、读取方法a、目录结构b、yaml文件c、测试方法d、测试用例e、测试结果三、数据驱动excel1、安装导入2、操作3、读取方法a、目录结构b、excel文件c、测…
阅读更多...
（考研湖科大教书匠计算机网络）第五章传输层-第七节：TCP可靠传输

（考研湖科大教书匠计算机网络）第五章传输层-第七节：TCP可靠传输

获取pdf&#xff1a;密码7281专栏目录首页&#xff1a;【专栏必读】考研湖科大教书匠计算机网络笔记导航 文章目录一&#xff1a;TCP可靠传输二&#xff1a;补充说明本节对应视频如下 【计算机网络微课堂&#xff08;有字幕无背景音乐版&#xff09;】&#xff1a;TCP可靠传输 …
阅读更多...
Navicat Premium 安装 注册

Navicat Premium 安装 注册

Navicat Premium 一.Navicat Premium的安装 1.暂时关闭windows的病毒与威胁防护弄完再开&#xff0c;之后安装打开过程中弹窗所有警告全部允许,不然会被拦住 2.下载安装包&#xff0c;解压 链接&#xff1a;https://pan.baidu.com/s/1X24VPC4xq586YdsnasE5JA?pwdu4vi 提取码…
阅读更多...
Qt 线程

Qt 线程

Qt中线程的解释&#xff1a; QThread(线程)&#xff0c;代表一个在应用程序中可以独立控制的线程&#xff0c;可以和进程中的其他线程分享数据。QThread 对象管理程序中的一个控制线程。QThreads 在 run&#xff08;&#xff09; 中开始执行。默认情况下&#xff0c;run&#…
阅读更多...
DDFN: Decoupled Dynamic Filter Networks解耦的动态卷积

DDFN: Decoupled Dynamic Filter Networks解耦的动态卷积

一、论文信息 论文名称&#xff1a;Decoupled Dynamic Filter Networks 论文&#xff1a;https://thefoxofsky.github.io/files/ddf.pdf 代码&#xff1a;https://github.com/theFoxofSky/ddfnet 主页&#xff1a;https://thefoxofsky.github.io/project_pages/ddf 作者团…
阅读更多...
kubectl常用的命令

kubectl常用的命令

目录 安装 kubectl 一、命令自动补全 二、常用命令 1、查看所有pod列表 2、查看RC和service列表 3、显示Node的详细信息 4、显示Pod的详细信息, 特别是查看Pod无法创建的时候的日志 5、 根据yaml创建资源, apply可以重复执行&#xff0c;create不行 6、基于nginx.yaml…
阅读更多...
实验室设计SICOLAB第三方检测中心实验室设计

实验室设计SICOLAB第三方检测中心实验室设计

第三方检测中心实验室怎么设计&#xff1f;详细设计内容有哪些&#xff1f;功能区域有哪些&#xff1f;仪器有哪些&#xff1f;要多少面积&#xff1f;第三方检测中心实验室是一种独立的实验室&#xff0c;为客户提供各种测试和分析服务。以下是一个第三方检测中心实验室的详细…
阅读更多...
给你安利几款好用的谷歌浏览器插件

给你安利几款好用的谷歌浏览器插件

给你安利几款好用的谷歌浏览器插件前言一 Octotree 插件二 GitCodeTree 插件三 SourceGraph 插件四 GitZip 插件五 Enhanced GitHub 插件六 插件下载安装6.1 谷歌应用商店下载6.2 离线安装6.2.1 下载插件6.2.2 安装插件七 移除、启用、停用插件小结前言 GitHub是全球最大的代码…
阅读更多...
Windows PowerShell中成功进入conda虚拟环境

Windows PowerShell中成功进入conda虚拟环境

本人操作系统是Windows10&#xff08;输入命令cmd或在运运行中输入winver查看&#xff09;在cmd命令行中大家都很熟悉&#xff0c;很方便进入到指定创建了的虚拟环境中&#xff0c;那么在PowerShell中怎么进入呢&#xff1f;比如在VSCode中的TERMINAL使用的是PowerShell&#x…
阅读更多...
论文阅读笔记-DiffusionInst: Diffusion Model for Instance Segmentation

论文阅读笔记-DiffusionInst: Diffusion Model for Instance Segmentation

文章目录DiffusionInst: Diffusion Model for Instance Segmentation摘要介绍任务介绍实例分割的几种方法想法来源贡献方法整体结构Mask RepresentationDiffusionInst组成TrainingInference不足之处感悟DiffusionInst: Diffusion Model for Instance Segmentation 代码&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023