【c++】哈希

QuiteCoder2025-01-18 10:01

🔥个人主页 ：Quitecoder

🔥专栏：c++笔记仓

目录

1. unordered系列关联式容器

在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 l o g 2 N log_2 N log2N，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11中，STL又提供了4个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同

1.1 unordered_map

  1. unordered_map是存储<key, value>键值对的关联式容器，其允许通过keys快速的索引到与其对应的value。
  2. 在unordered_map中，键值通常用于惟一地标识元素，而映射值是一个对象，其内容与此键关联。键和映射值的类型可能不同。
  3. 在内部,unordered_map 没有 对<kye, value>按照任何特定的顺序排序, 为了能在常数范围内找到key所对应的value，unordered_map将相同哈希值的键值对放在相同的桶中。
  4. unordered_map容器通过key访问单个元素要比map快，但它通常在遍历元素子集的范围迭代方面效率较低。
  5. unordered_maps实现了直接访问操作符(operator[])，它允许使用key作为参数直接访问value。
  6. 它的迭代器至少是前向迭代器

1.2 接口函数

operator[]：注意：该函数中实际调用哈希桶的插入操作**，用参数key与V()构造一个默认值往底层哈希桶中插入，如果key不在哈希桶中，插入成功，返回V()，插入失败，说明key已经在哈希桶中，将key对应的value返回**

iterator find(const K& key) 返回key在哈希桶中的位置

size_t count(const K& key) 返回哈希桶中关键码为key的键值对的个数

insert 向容器中插入键值对

erase 删除容器中的键值对

void clear() 清空容器中有效元素个数

void swap(unordered_map&) 交换两个容器中的元素

例题

题目链接 ：重复N次的元素
题目描述 ：

cpp 复制代码 
class Solution {
public:
    int repeatedNTimes(vector<int>& nums) {
        unordered_map<int,int> mp;
        int n=nums.size()/2;
        for(auto e:nums)
        {
            mp[e]++;
        }
        for(auto&e:mp)
        {
            if(e.second==n)
            {
                return e.first;
            }
        }
        return -1;
    }
};

题目链接 ：两个数组的交集
题目描述 ：

cpp 复制代码 
class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> s1;
        unordered_set<int> s2;
        for(auto e:nums1)
        {
            s1.insert(e);
        }
        for(auto e:nums2)
        {
            s2.insert(e);
        }
        vector<int> res;
        for(auto e:s1)
        {
            if(s2.find(e)!=s2.end())
            res.push_back(e);
        }
        return res;
    }
};

题目链接 ：两个数组的交集2
题目描述 ：

cpp 复制代码 
class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        unordered_map<int,int> mp;
        vector<int> res;   
       
        for(auto e:nums1)
        {
            mp[e]++;
        }
        for(auto e:nums2)
        {
            if(mp[e]!=0)
            {
                res.push_back(e);
                mp[e]--;
            }
        }
        return res;
    }
};

2.哈希概念

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O( l o g 2 N log_2 N log2N)，搜索的效率取决于搜索过程中元素的比较次数。

理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。
如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素

当向该结构中：

  • 插入元素
    根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
  • 搜索元素
    对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功

该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数 ，构造出来的结构称为哈希表(Hash Table)(或者称散列表)

例如：数据集合{1，7，6，4，5，9}；

哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小

用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快

问题：按照上述哈希方式，向集合中插入元素44，会出现什么问题？

2.1哈希冲突

对于两个数据元素的关键字 k i k_i ki和 k j k_j kj(i != j)，有 k i k_i ki != k j k_j kj，但有：Hash( k i k_i ki) == Hash( k j k_j kj)，即：不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞

把具有不同关键码而具有相同哈希地址的数据元素称为同义词

2.2哈希函数

引起哈希冲突的一个原因可能是：哈希函数设计不够合理。

哈希函数设计原则：

  • 哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间
  • 哈希函数计算出来的地址能均匀分布在整个空间中
  • 哈希函数应该比较简单

  1. 直接定址法--(常用)

    • 取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B
    • 优点：简单、均匀
    • 缺点：需要事先知道关键字的分布情况
    • 使用场景：适合查找比较小且连续的情况

  2. 除留余数法--(常用)

    设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，

    按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址

2.3哈希冲突解决

解决哈希冲突两种常见的方法是：闭散列和开散列

闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的"下一个" 空位置中去

2.3.1线性探测

线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止

  • 插入
    *
    • 通过哈希函数获取待插入元素在哈希表中的位置
      • 如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素
  • 删除
    • 采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素 ，若直接删除元素会影响其他元素的搜索。比如删除元素4，如果直接删除掉，44查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素

代码实现：

首先设置每个位置的状态：

cpp 复制代码 
enum State
{
	Empty,Exist,Delete
};

Empty此位置空，Exist此位置已经有元素， Delete元素已经删除

cpp 复制代码 
enum State
{
	Empty,Exist,Delete
};


template<class K,class V>
struct HashData
{
	pair<K, V> _kv;
	State _state;
};

template<class K, class V>
class HashTable
{
public:
	bool Insert(const pair<K,V>& kv)
	{
		size_t hashi = kv.first % _tables.size();
		while (_tables[hashi]._state == Exist)
		{
			++hashi;
			hashi %= _tables.size();
		}
		_tables[hashi]._kv = kv;
		_tables[hashi]._state = Exist;
		++_n;
	}
private:
	vector<HashData<K, V>> _tables;
	size_t _n;//有效数据个数
};

hashi 是通过 kv.first % _tables.size() 计算出的初始索引，用于确定存储桶的位置。如果该位置已经被占用（状态为 Exist），则通过线性探测法找到下一个空位置

这里就有一个问题：如果存储满了，那么程序会陷入死循环，那么我们就需要进行扩容

负载因子越高，冲突率越高，效率就越低
负载因子越低，冲突率越低，效率就越高，但空间利用率就越低

这种关联式容器的扩容不仅仅是拷贝下来，还得考虑数据与模的大小的关系

所以，先进行扩容，再将原有的值重新映射

第一步优化：

cpp 复制代码 
template<class K,class V>
struct HashData
{
	pair<K, V> _kv;
	State _state=Empty;
};

template<class K, class V>
class HashTable
{
public:
	HashTable()
	{
		_tables.resize(10);
	}
	bool Insert(const pair<K,V>& kv)
	{
		if (_n * 10 / _tables.size() >= 7)
		{

		}
		size_t hashi = kv.first % _tables.size();
		while (_tables[hashi]._state == Exist)
		{
			++hashi;
			hashi %= _tables.size();
		}
		_tables[hashi]._kv = kv;
		_tables[hashi]._state = Exist;
		++_n;
	}
private:
	vector<HashData<K, V>> _tables;
	size_t _n=0;//有效数据个数
};

增加构造函数与缺省值，对于内置类型_state，我们设置它初始状态为Empty

cpp 复制代码 
bool Insert(const pair<K,V>& kv)
{
	if (Find(kv.first)) return false;
	if (_n * 10 / _tables.size() >= 7)
	{
		/*size_t newsize = _tables.size() * 2;
		vector<HashData<K, V>> newtables(newsize);*/

		//旧表重新计算负载到新表
		size_t newsize = _tables.size() * 2;
		HashTable<K, V> newHashTable;
		newHashTable._tables.resize(newsize);
		for (size_t i = 0; i < _tables.size(); i++)
		{
			if (_tables[i]._state == Exist)
			{
				newHashTable.Insert(_tables[i]._kv);
			}
		}
		*this = std::move(newHashTable);//_tables.swap(newHashTable._tables);
	}
	size_t hashi = kv.first % _tables.size();
	while (_tables[hashi]._state == Exist)
	{
		++hashi;
		hashi %= _tables.size();
	}
	_tables[hashi]._kv = kv;
	_tables[hashi]._state = Exist;
	++_n;

	return true;
}

这里我们直接在函数里面构建一个新的哈希表，再if里面调用insert永远不会再进入第一个if判断，因为我这里的空间大小已经开好了，后面直接调用映射的部分，最后更新原哈希表即可

cpp 复制代码 
HashData<K, V>* Find(const K&key)
{
	size_t hashi = key % _tables.size();
	while (_tables[hashi]._state != Empty)
	{
		if (_tables[hashi]._state==Exist&&_tables[hashi]._kv.first == key) return &_tables[hashi];

		++hashi;
		hashi %= _tables.size();
	}
	return nullptr;
}
bool Erase(const K& key)
{
	HashData<K, V>* ret = Find(key);
	if (ret == nullptr) return false;
	else
	{
		ret->_state = Delete;
		--_n;
		return true;
	}
}

这两个函数搭配使用，我第一个返回地址，第二个根据是否能找到的索引来进行修改，非常方便

线性探测优点：实现非常简单，

线性探测缺点：一旦发生哈希冲突，所有的冲突连在一起，容易产生数据"堆积"，即：不同关键码占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降低

这里还有一个问题：如果我插入的是K是string之类的，我该如何取模呢？

cpp 复制代码 
template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};

struct StringHashFunc
{
	size_t operator()(const string& key)
	{
		size_t hash = 0;
		for (auto e : key)
		{
			hash += e;
		}
		return hash;
	}
};

template<class K, class V,class Hash=HashFunc<K>>
class HashTable
{------------------------------

默认的仿函数进行对数据的转换，比如负数，浮点型直接强转为size_t，对于string类我们特化一个仿函数，返回它的ascll值之和

cpp 复制代码 
Hash hs;
size_t hashi = hs(kv.first) % _tables.size();
二次探测

线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为： H i H_i Hi = ( H 0 H_0 H0 + i 2 i^2 i2 )% m, 或者： H i H_i Hi = ( H 0 H_0 H0 - i 2 i^2 i2 )% m。其中：i = 1,2,3...， H 0 H_0 H0是通过散列函数Hash(x)对元素的关键码 key 进行计算得到的位置，m是表的大小

2.3.2开散列

开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中

开散列中每个桶中放的都是发生哈希冲突的元素

代码：

cpp 复制代码 
template<class K, class V>
struct HashNode
{
	pair<K, V> _kv;
	HashNode<K, V>* _next;
};

template<class K, class V>
class HashTable
{
public:
	typedef HashNode<K, V> Node;
	HashTable()
{
	_tables.resize(10, nullptr);
}
private:
	vector<Node*> _tables;
	size_t _n=0;
};

插入函数依旧复用，这里用链表的头插

cpp 复制代码 
bool Insert(const pair<K, V>& kv)
{
	if (_n == _tables.size())
	{
		HashTable<K, V> newHT;
		newHT._tables.resize(_tables.size() * 2);
		for (size_t i = 0; i < _tables.size(); i++)
		{
			Node* cur = _tables[i];
			while (cur) 
			{
				newHT.Insert(cur->kv);
				cur = cur->_next;
			}
		}
		_tables.swap(newHT._tables);
	}
	size_t hashi = kv.first & _tables.size();
	Node* newnode = new Node(kv);
	//头插
	newnode->_next = _tables[hashi];
	_tables[hashi] = newnode;
	++_n;
	return true;
}

这里有一个问题，我如果重新插入，那么原来的节点就需要手动去释放，非常麻烦，我们这里可以直接复用上面的节点

cpp 复制代码 
bool Insert(const pair<K, V>& kv)
{
	if (_n == _tables.size())
	{
		vector<Node*> newTables(_tables.size()*2,nullptr);
		for (size_t i = 0; i < _tables.size(); i++)
		{
			Node* cur = _tables[i];
			while (cur)
			{
				//头插到新表的位置
				Node* next = cur->_next;
				size_t hashi = cur->_kv.first % newTables.size();
				cur->_next = newTables[hashi];
				newTables[hashi] = cur;
				cur = next;
			}
			_tables[i] = nullptr;
		}
		
		_tables.swap(newTables);
	}
	size_t hashi = kv.first & _tables.size();
	Node* newnode = new Node(kv);
	//头插
	newnode->_next = _tables[hashi];
	_tables[hashi] = newnode;
	++_n;
	return true;
}

取出一个节点放到新的表中，每次取完一组后置空，最后交换

cpp 复制代码 
bool Erase(const K& key)
{
	size_t hashi = key % _tables.size();
	Node* cur = _tables[hashi];
	Node* pre = nullptr;
	while (cur)
	{
		if (cur->_kv.first == key)
		{
			if (pre == nullptr)
			{
				_tables[hashi]=cur->_next；
			}
			else
			{
				pre->_next = cur->_next;
			}

			delete cur;
		}
		else
		{
			prev = cur;
			cur = cur->_next;
		}
	}
}

补充仿函数：

cpp 复制代码 
template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
    }
};

struct StringHashFunc
{
	size_t operator()(const string& key)
	{
		size_t ch = 0;
		for (auto e : key)
		{
			ch += e ;
		}
		return ch;
	}
};

3. 封装

cpp 复制代码 
template<class T>
struct HashNode
{
	T _data;
	HashNode<T>* _next;

	HashNode(const T& data)
		:_data(data),
		_next(nullptr)
	{}
};

template<class K, class T,class Hash =HashFunc<K>>
class HashTable
{
public:
	typedef HashNode<T> Node;

Node设置一个模版参数T，对于unordered_set 传入K，对于unordered_map 传入pair<K,V>，跟之前set，map封装类似,再增加一个KeyofT的仿函数

cpp 复制代码 
template<class K,class V> 
class Unordered_map
{
public:
	struct MapKeyOfT
	{
		const K& operator()(const pair<K, V>& kv)
		{
			return kv.first;
		}
	};
private:
	HashTable<K, pair<K, V>,MapKeyOfT> _ht;
};
cpp 复制代码 
template<class K>
class Unordered_set
{
public:
	struct SetKeyOfT
	{
		const K& operator()(const K& key)
		{
			return key;
		}
	};
private:
	HashTable<K, K,SetKeyOfT> _ht;
};

迭代器封装

cpp 复制代码 
template<class K,class T,class KeyofT,class Hash>
class _HTIterator
{

	typedef<HashNode<T>> Node;
	Node* _node;
	HashTable<K, V, KeyofT, Hash>* _pht;
	operator++()
	{
		if (_node->next)
		{
			_node = node->next;
		}
		else
		{
           
		}
	}
};

库里面直接将哈希表的地址穿过来以便迭代器来遍历


找到第一个节点，返回iterator，构造函数返回当前节点指针和哈希表，this就派上用场了

cpp 复制代码 
Self& operator++()
{
	if (_node->next)
	{
		//当前桶没走完
		_node = node->next;
	}
	else
	{
		//找不为空的桶
		KeyofT kot;
		Hash hs;
		size_t i = hs(kot(_node->_data)) % _pht->_tables.size();//仿函数叠加
		++i;
		for (; i < _pht->_tables.size(); i++)
		{
			if (_pht->_tables[i]) break;
		}
		if (i == _pht->_tables.size()) _node = nullptr;
		else _node = _pht->_tables[i];
	}
	return *this;
}

完整代码：

cpp 复制代码 
#pragma once
#include<iostream>
#include<vector>
using namespace std;

template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
    }
};

struct StringHashFunc
{
	size_t operator()(const string& key)
	{
		size_t ch = 0;
		for (auto e : key)
		{
			ch += e ;
		}
		return ch;
	}
};

template<class T>
struct HashNode
{
	T _data;
	HashNode<T>* _next;

	HashNode(const T& data)
		:_data(data),
		_next(nullptr)
	{}
};
template<class K, class T, class KeyofT, class Hash>//前置声明
class HashTable;

template<class K,class T,class KeyofT,class Hash>
class _HTIterator
{
public:
	typedef HashNode<T> Node;
	typedef _HTIterator<K, T, KeyofT, Hash> Self;
	Node* _node;
	HashTable<K, T, KeyofT, Hash>* _pht;

	_HTIterator(Node* node, HashTable<K, T, KeyofT, Hash>* pht)
		:_node(node),
		_pht(pht)
	{}
	Self& operator++()
	{
		if (_node->_next)
		{
			//当前桶没走完
			_node = _node->_next;
		}
		else
		{
			//找不为空的桶
			KeyofT kot;
			Hash hs;
			size_t i = hs(kot(_node->_data)) % _pht->_tables.size();//仿函数叠加
			++i;
			for (; i < _pht->_tables.size(); i++)
			{
				if (_pht->_tables[i]) break;
			}
			if (i == _pht->_tables.size()) _node = nullptr;
			else _node = _pht->_tables[i];
		}
		return *this;
	}
	bool operator!=(const Self& s)
	{
		return _node != s._node;
	}
	T& operator*()
	{
		return _node->_data;
	}
};
template<class K, class T, class KeyofT, class Hash = HashFunc<K>>
class HashTable
{
public:
	template<class K, class T, class KeyofT, class Hash>
	friend class _HTIterator;
	typedef _HTIterator<K, T, KeyofT, Hash> iterator;

	iterator begin()
	{
		for (size_t i = 0; i < _tables.size();i++)
		{
			Node* cur = _tables[i];
			if (cur)
			{
				return iterator(cur, this);
			}
		}
	}
	iterator end()
	{
		return iterator(nullptr, this);
	}
	typedef HashNode<T> Node;
	HashTable()
	{
		_tables.resize(10, nullptr);
	}
	~HashTable()
	{
		for (size_t i = 0; i < _tables.size(); i++)
		{
			Node* cur = _tables[i];
			while (cur)
			{
				Node* next = cur->_next;
				delete cur;
				cur = next;
			}
			_tables[i] = nullptr;
		}
	}
	//bool Insert(const pair<K, V>& kv)
	//{
	//	if (_n == _tables.size())
	//	{
	//		HashTable<K, V> newHT;
	//		newHT._tables.resize(_tables.size() * 2);
	//		for (size_t i = 0; i < _tables.size(); i++)
	//		{
	//			Node* cur = _tables[i];
	//			while (cur) 
	//			{
	//				newHT.Insert(cur->kv);
	//				cur = cur->_next;
	//			}
	//		}
	//		_tables.swap(newHT._tables);
	//	}
	//	size_t hashi = kv.first & _tables.size();
	//	Node* newnode = new Node(kv);
	//	//头插
	//	newnode->_next = _tables[hashi];
	//	_tables[hashi] = newnode;
	//	++_n;
	//	return true;
	//}
	bool Insert(const T& data)
	{
		HashFunc<K> hs;
		KeyofT kot;
		if (Find(kot(data))) return false;
		if (_n == _tables.size())
		{
			vector<Node*> newTables(_tables.size()*2,nullptr);
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					//头插到新表的位置
					Node* next = cur->_next;
					size_t hashi = hs(kot(cur->_data)) % newTables.size();
					cur->_next = newTables[hashi];
					newTables[hashi] = cur;
					cur = next;
				}
				_tables[i] = nullptr;
			}
			
			_tables.swap(newTables);
		}
		size_t hashi = hs(kot(data)) % _tables.size();
		Node* newnode = new Node(data);
		//头插
		newnode->_next = _tables[hashi];
		_tables[hashi] = newnode;
		++_n;
		return true;
	}
	bool Erase(const K& key)
	{
		KeyofT kot;                  // KeyofT 实例化
		HashFunc<K> hs;
		size_t hashi = hs(key) % _tables.size();
		Node* cur = _tables[hashi];
		Node* pre = nullptr;
		while (cur)
		{
			// 使用 kot(cur->_data) 来获取当前节点的数据的键
			if (kot(cur->_data) == key)
			{
				if (pre == nullptr)
				{
					_tables[hashi] = cur->_next;
				}
				else
				{
					pre->_next = cur->_next;
				}
				delete cur;
				--_n;
				return true;
			}
			else
			{
				pre = cur;
				cur = cur->_next;
			}
		}
		return false;
	}
	Node* Find(const K& key)
	{
		KeyofT kot;
		HashFunc<K> hs;
		size_t hashi = hs(key) % _tables.size();
		Node* cur = _tables[hashi];
		while (cur)
		{
			if (kot(cur->_data) == key) return cur;

			cur = cur->_next;
		}
		return nullptr;
	}
private:
	vector<Node*> _tables;
	size_t _n=0;
};
cpp 复制代码 
#pragma once
#include"HashBucket.h"

template<class K>
class Unordered_set
{
public:
	struct SetKeyOfT
	{
		const K& operator()(const K& key)
		{
			return key;
		}
	};
	typedef typename HashTable<K, K, SetKeyOfT>::iterator iterator;
	iterator begin()
	{
		return _ht.begin();
	}
	iterator end()
	{
		return _ht.end();
	}
	bool insert(const K& key)
	{
		return _ht.Insert(key);
	}
private:
	HashTable<K, K,SetKeyOfT> _ht;
};


void testset()
{
	Unordered_set<int> s;
	s.insert(31);
	s.insert(11);
	s.insert(5);
	s.insert(15);
	s.insert(20);
	Unordered_set<int>::iterator it = s.begin();
	while (it != s.end())
	{
		cout << *it << " ";
		++it;
	}
}
相关推荐
I"ll carry you22 分钟前
【C++基础】enum，union，uint8_t，static
java·数据库·c++
Zfox_25 分钟前
【Linux】应用层自定义协议与序列化
linux·服务器·c语言·c++
*TQK*44 分钟前
C++/C语言判断重复数组（zznu）⭐
c语言·数据结构·c++
可涵不会debug2 小时前
Git在码云上的使用指南：从安装到推送远程仓库
linux·运维·服务器·c++·git
Flocx2 小时前
联合体（Union）
开发语言·网络·c++·stm32
迂幵myself2 小时前
14-1C++STL的初始
开发语言·c++
羑悻的小杀马特3 小时前
【狂热算法篇】探秘图论之 Floyd 算法：解锁最短路径的神秘密码(通俗易懂版)
c++·算法·图论·floyd算法
0xCC说逆向3 小时前
Windows图形界面(GUI)-QT-C/C++ - QT 对话窗口
java·c语言·开发语言·c++·windows·qt·microsoft
计算机小混子3 小时前
C++实现设计模式---享元模式 (Flyweight)
c++·设计模式·享元模式
热门推荐
01Oracle Scheduler: Calendaring02Dell服务器升级ubuntu 22.04失败解决03半导体应用系统一些小知识收集(strip&wafer mapping,EAP&scada)04(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明05密码学原理技术-第六章-introduction to pulibc-key cryptography06优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间07Oracle 高阶函数与高级功能详解08go下载依赖提示连接失败09渗透测试之SQLMAP工具详解 kali自带SQLmap解释 重点sqlmap --tamper 使用方式详解 搞完你就很nice了10flask-admin 在modelview 默认视图下重写create_model_actions来实现列表数据的批量处理actions