哈希

在这里插入图片描述

欢迎来到Cefler的博客😁
🕌博客主页：那个传说中的man的主页
🏠个人专栏：题目解析
🌎推荐文章：题目大解析（3）

在这里插入图片描述

目录

  • 👉🏻unordered系列关联式容器
    • unordered_map
    • unordered_set
  • 👉🏻哈希概念
  • 👉🏻哈希函数
  • 👉🏻哈希冲突
  • 👉🏻 哈希冲突解决方法
    • 闭散列
      • 线性探测
  • 👉🏻哈希闭散列模拟实现
    • 哈希数据和哈希状态
    • 返回哈希值的key
    • 哈希插入（含扩容和线性探测）
    • 哈希查找
    • 哈希的伪删除
    • 哈希打印
    • 哈希闭散列完整代码附测试代码
  • 👉🏻哈希开散列（哈希桶）模拟实现
    • 概念
    • 哈希节点
    • 哈希插入（含扩容）
    • 析构函数
    • 返回哈希值的key
    • 哈希查找
    • 哈希删除
    • 显示哈希的一些情况（桶的数量、长度等）
    • 哈希开散列完整代码附测试代码

👉🏻unordered系列关联式容器

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

unordered_map

unordered_map官方文档： 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. 它的迭代器至少是前向迭代器

unordered_set

unordered_set官方文档：unordered_set

1.无序集合是存储没有特定顺序的唯一元素的容器，它允许基于它们的值快速检索单个元素。

2.在unordered_set中，元素的值同时也是唯一标识它的键。键是不可变的，因此，在容器中不能修改unordered_set中的元素——但是可以插入和删除它们。

3.在内部，unordered_set中的元素没有按照任何特定的顺序排序，而是根据它们的散列值组织到bucket中，以便通过它们的值直接快速访问单个元素(平均时间复杂度为常数)。

4.Unordered_set容器在按键访问单个元素时比set容器快，尽管它们在通过其元素子集进行范围迭代时通常效率较低。

5.容器中的迭代器至少是前向迭代器。

👉🏻哈希概念

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

理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。

如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。
当向该结构中：

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

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

  • 哈希/散列：映射，关键字和另一个值建立一个关联关系

  • 哈希表/散列表：映射，关键字和存储位置建立一个关联关系

👉🏻哈希函数

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

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

☃️常见的哈希函数有：

  1. 直接定址法–(常用)
    取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B
    优点：简单、均匀，关键字—存储位置是一对一的关系，不存在哈希冲突
    缺点：需要事先知道关键字的分布情况
    使用场景：关键字范围集中，量不大的情况

  2. 除留余数法–(常用)
    设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，
    按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址
    其关键字-存储位置是多对一的关系，多个关键字对应一个位置，存在哈希冲突
    使用场景：关键字可以很分散，量可以很大

例如该下面这个就是采取除留余数法

数据集合：{1，7，6，4，5，9}；
哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。

在这里插入图片描述
用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快
问题：按照上述哈希方式，向集合中插入元素44，会出现什么问题？

👉🏻哈希冲突

🧋 概念 概念 概念
对于两个数据元素的关键字 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​)，即：不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。

把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。
发生哈希冲突该如何处理呢？ 🤔

👉🏻 哈希冲突解决方法

闭散列

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

线性探测

比如刚刚的场景中，现在需要插入元素44，先通过哈希函数计算哈希地址，hashAddr为4，
因此44理论上应该插在该位置，但是该位置已经放了值为4的元素，即发生哈希冲突。
线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。
线性探测向后找可以表示为：hashi+i(i>=0)

即线性探测的插入和删除表现为：

  • 插入

1.通过哈希函数获取待插入元素在哈希表中的位置
2.如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素

  • 删除

采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如删除元素4，如果直接删除掉，44查找起来可能会受影响，因为我们查找到4时，此时4的位置为空，我们就停下来了不往后找，自然就找不到44了。因此线性探测采用标记的伪删除法(标记状态为DELETE)来删除一个元素。

👉🏻哈希闭散列模拟实现

哈希数据和哈希状态

enum Status{EMPTY,EXIST,DELETE};template <class K, class V>struct HashData{pair<K, V> _kv;Status _s;};

返回哈希值的key

1.常规类型返回：如int、double等

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

2.字符串类型返回
这个就不能直接返回字符串，因为字符串是不能用于取余的，但是我们可以将字符串中的每一个字符的ASCII码值全部相加以整型的形式返回即可。
但是我们知道字符串的组合是无数种的，可size_t的值却是有上限的，那么多字符串最终会有很多字符串相加的ASCII码值会相等，这就会发生哈希冲突。对于哈希冲突，我们不可避免，但是在这个基础上，有算法大佬提供了牛逼的算法，可以减少这之间的哈希冲突的产生。
以下是一个著名的BRDK算法
在这里插入图片描述
我们借鉴这个算法进行将字符串转换为整型返回

template<>struct HashFunc<string>{size_t operator()(const string& key){size_t hash = 0;for (auto e : key){hash = hash * 31 + e;}return hash;}};

我们观察到针对于这两种情况，我们都是采用了模板进行实例化，而字符串类型返回比较特殊这边用了全特化。
有人可能会问，为什么不把写成类的函数重载，而是用模板特化？
答案是这里会出现坑，当我们进行函数重载时，如果传进来的K是string,此时类中就会有两个size_t operator()(const string& key)，发生冲突。
而特化就可以解决这个问题。

哈希插入（含扩容和线性探测）

🌊扩容：

//如果空间不够？//负载因子0.7就扩容if (_n * 10 / _tables.capacity() == 7){//不能原地扩容，因为原地扩容会使映射关系发生变化，比如size(10)->size(20),原本3的位置会变到13去//所以我们开辟新空间size_t newSize = _tables.size() * 2;HashTable<K, V,Hash> newHT;newHT._tables.resize(newSize);//遍历旧表，将旧表的值插入到新表中for (int i = 0; i < _tables.size(); i++){if (_tables[i]._s == EXIST){newHT.Insert(_tables[i]._kv);}}//最后旧表变新表_tables.swap(newHT._tables);}

🌊线性探测:

Hash hf;//HashFuncsize_t hashi = hf(kv.first) % _tables.size();//size_t可以解决负数问题，负数隐式类型转换为无符号while (_tables[hashi]._s== EXIST) {//存在则找下一个空位置hashi++;hashi %= _tables.size();}_tables[hashi]._kv = kv;_tables[hashi]._s = EXIST;++_n;return true;

整体插入代码：

bool Insert(const pair<K, V>& kv){if (Find(kv.first))return false;//如果空间不够？//负载因子0.7就扩容if (_n * 10 / _tables.capacity() == 7){//不能原地扩容，因为原地扩容会使映射关系发生变化，比如size(10)->size(20),原本3的位置会变到13去//所以我们开辟新空间size_t newSize = _tables.size() * 2;HashTable<K, V，Hash> newHT;newHT._tables.resize(newSize);//遍历旧表，将旧表的值插入到新表中for (int i = 0; i < _tables.size(); i++){if (_tables[i]._s == EXIST){newHT.Insert(_tables[i]._kv);}}//最后旧表变新表_tables.swap(newHT._tables);}//线性探测Hash hf;//HashFuncsize_t hashi = hf(kv.first) % _tables.size();//size_t可以解决负数问题，负数隐式类型转换为无符号while (_tables[hashi]._s== EXIST) {//存在则找下一个空位置hashi++;hashi %= _tables.size();}_tables[hashi]._kv = kv;_tables[hashi]._s = EXIST;++_n;return true;}

哈希查找

//哈希查找HashData<K, V>* Find(const K& key){Hash hf;size_t hashi = hf(key) % _tables.size();while (_tables[hashi]._s != EMPTY){if (_tables[hashi]._s == EXIST && _tables[hashi]._kv.first == key){return &_tables[hashi];}++hashi;hashi %= _tables.size();}return nullptr;}

哈希的伪删除

伪删除就很简单，直接找到对应的位置，将该位置的状态改为DELETE,然后_n减一即可。

//伪删除bool Erase(const K& key){HashData<K, V>* ret = Find(key);if (ret){ret->_s = DELETE;_n--;return true;}elsereturn false;}

哈希打印

//打印void Print(){for (size_t i = 0; i < _tables.size(); i++){if (_tables[i]._s == EXIST){//printf("[%d]->%d\n", i, _tables[i]._kv.first);cout << "[" << i << "]->" << _tables[i]._kv.first << ":" << _tables[i]._kv.second << endl;}else if (_tables[i]._s == EMPTY){printf("[%d]->\n", i);}else{printf("[%d]->D\n", i);}}cout << endl;}

哈希闭散列完整代码附测试代码

#pragma once
#include<iostream>
#include<vector>
using namespace std;
namespace close_address
{enum Status{EMPTY,EXIST,DELETE};template <class K, class V>struct HashData{pair<K, V> _kv;Status _s;};//返回哈希的key//1.常规类型template <class  K>struct HashFunc{size_t operator()(const K& key){return (size_t)key;}};//2.字符串转换为整型返回template<>struct HashFunc<string>{size_t operator()(const string& key){size_t hash = 0;for (auto e : key){hash = hash * 31 + e;}return hash;}};template <class K,class V,class Hash = HashFunc<K>>class HashTable{public:HashTable(){_tables.resize(10);//一开始扩容为10}bool Insert(const pair<K, V>& kv){if (Find(kv.first))return false;//如果空间不够？//负载因子0.7就扩容if (_n * 10 / _tables.capacity() == 7){//不能原地扩容，因为原地扩容会使映射关系发生变化，比如size(10)->size(20),原本3的位置会变到13去//所以我们开辟新空间size_t newSize = _tables.size() * 2;HashTable<K, V,Hash> newHT;newHT._tables.resize(newSize);//遍历旧表，将旧表的值插入到新表中for (int i = 0; i < _tables.size(); i++){if (_tables[i]._s == EXIST){newHT.Insert(_tables[i]._kv);}}//最后旧表变新表_tables.swap(newHT._tables);}//线性探测Hash hf;//HashFuncsize_t hashi = hf(kv.first) % _tables.size();//size_t可以解决负数问题，负数隐式类型转换为无符号while (_tables[hashi]._s== EXIST) {//存在则找下一个空位置hashi++;hashi %= _tables.size();}_tables[hashi]._kv = kv;_tables[hashi]._s = EXIST;++_n;return true;}//哈希查找HashData<K, V>* Find(const K& key){Hash hf;size_t hashi = hf(key) % _tables.size();while (_tables[hashi]._s != EMPTY){if (_tables[hashi]._s == 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){ret->_s = DELETE;_n--;return true;}elsereturn false;}//打印void Print(){for (size_t i = 0; i < _tables.size(); i++){if (_tables[i]._s == EXIST){//printf("[%d]->%d\n", i, _tables[i]._kv.first);cout << "[" << i << "]->" << _tables[i]._kv.first << ":" << _tables[i]._kv.second << endl;}else if (_tables[i]._s == EMPTY){printf("[%d]->\n", i);}else{printf("[%d]->D\n", i);}}cout << endl;}private:vector<HashData<K,V>> _tables;size_t _n = 0;//存储关键字的个数};void TestHT1(){HashTable<int, int> ht;int a[] = { 4,14,24,34,5,7,1 };for (auto e : a){ht.Insert(make_pair(e, e));}ht.Print();}void TestHT2(){string arr[] = { "香蕉", "甜瓜","苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };//HashTable<string, int, HashFuncString> ht;HashTable<string, int> ht;for (auto& e : arr){//auto ret = ht.Find(e);HashData<string, int>* ret = ht.Find(e);if (ret){ret->_kv.second++;}else{ht.Insert(make_pair(e, 1));}}ht.Print();ht.Insert(make_pair("apple", 1));ht.Insert(make_pair("sort", 1));ht.Insert(make_pair("abc", 1));ht.Insert(make_pair("acb", 1));ht.Insert(make_pair("aad", 1));ht.Print();}
}

👉🏻哈希开散列（哈希桶）模拟实现

概念

开放寻址法（Open Addressing）是一种解决哈希冲突的方法。在开放寻址法中，当发生冲突时，会通过一定的探测序列（如线性探测、二次探测等）在哈希表中的其他位置继续寻找空闲槽来存储冲突的元素。

而开散列（Open Hashing），也被称为链地址法（Chaining），是另一种解决哈希冲突的方法。在开散列中，具有相同地
址的关键码归于同一子集合，每一个子集合称为一个桶，当发生哈希冲突时，冲突的元素会被链接成一个链表或其他数据结构存储在同一个桶中。

在这里插入图片描述

哈希节点

template<class K,class V>struct HashNode{HashNode<K, V>* _next;pair<K, V> _kv;HashNode(const HashNode<K,V>& kv):_kv(kv._kv),_next(nullptr){}};

哈希插入（含扩容）

bool Insert(const pair<K, V>& kv){if (Find(kv.first))return false;//扩容，这里负载因子可以最大到1if (_n == _tables.size()){size_t newSize() = _tables.size() * 2;HashTable<K,V> newHT;newHT._tables.resize(newSize);//遍历旧表，插入新表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);}//插入的新节点头插Hash hf;size_t hashi = hf(kv.first) % _tables.size();Node* newnode = new Node(kv);newnode->_next = _tables[hashi];_tables[hashi] = newnode;_n++;return true;}

扩容方法2：

if (_n == _tables.size()){vector<Node*> newTables;newTables.resize(_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 = hf(cur->_kv.first) % newTables.size();cur->_next = newTables[i];newTables[i] = cur;cur = next;}_tables[i] = nullptr;}_tables.swap(newTables);}

析构函数

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

返回哈希值的key

//返回哈希的key//1.常规类型template <class  K>struct HashFunc{size_t operator()(const K& key){return (size_t)key;}};//2.字符串转换为整型返回template<>struct HashFunc<string>{size_t operator()(const string& key){size_t hash = 0;for (auto e : key){hash = hash * 31 + e;}return hash;}};

哈希查找

//哈希查找Node* Find(const K& key){Hash hf;size_t hashi = hf(key) % _tables.size();Node* cur = _tables[hashi];while (cur){if (cur->_next == key){return cur;}cur = cur->_next;}return nullptr;}

哈希删除

//哈希删除bool Erase(const K& key){Hash hf;size_t hashi = hf(key) % _tables.size();Node* cur = _tables[hashi];Node* prev = nullptr;while (cur){if (cur->_kv.first == key){if (prev == nullptr){_tables[hashi] = cur->_next;}else{prev->_next = cur->_next;}delete cur;return true ;}prev = cur;cur = cur->_next;}return false;}

显示哈希的一些情况（桶的数量、长度等）

void Some(){size_t bucketSize = 0;size_t maxBucketLen = 0;size_t sum = 0;double averageBucketLen = 0;for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];if (cur){++bucketSize;}size_t bucketLen = 0;while (cur){++bucketLen;cur = cur->_next;}sum += bucketLen;if (bucketLen > maxBucketLen){maxBucketLen = bucketLen;}}averageBucketLen = (double)sum / (double)bucketSize;printf("all bucketSize:%d\n", _tables.size());printf("bucketSize:%d\n", bucketSize);printf("maxBucketLen:%d\n", maxBucketLen);printf("averageBucketLen:%lf\n\n", averageBucketLen);}

哈希开散列完整代码附测试代码

#pragma once
#include<iostream>
#include<vector>
#include<unordered_set>
#include<set>
using namespace std;
namespace hash_bucket
{template<class K,class V>struct HashNode{HashNode<K, V>* _next;pair<K, V> _kv;HashNode(const pair<K,V>& kv):_kv(kv),_next(nullptr){}};//返回哈希的key//1.常规类型template <class  K>struct HashFunc{size_t operator()(const K& key){return (size_t)key;}};//2.字符串转换为整型返回template<>struct HashFunc<string>{size_t operator()(const string& key){size_t hash = 0;for (auto e : key){hash = hash * 31 + e;}return hash;}};template<class K,class V,class Hash = HashFunc<K>>class HashTable{public:typedef HashNode<K, V> Node;HashTable(){_tables.resize(10);}~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 (Find(kv.first))return false;//扩容，这里负载因子可以最大到1if (_n == _tables.size()){size_t newSize = _tables.size() * 2;HashTable<K,V> newHT;newHT._tables.resize(newSize);//遍历旧表，插入新表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);}//插入的新节点头插Hash hf;size_t hashi = hf(kv.first) % _tables.size();Node* newnode = new Node(kv);newnode->_next = _tables[hashi];_tables[hashi] = newnode;_n++;return true;}//哈希查找Node* Find(const K& key){Hash hf;size_t hashi = hf(key) % _tables.size();Node* cur = _tables[hashi];while (cur){if (cur->_kv.first == key){return cur;}cur = cur->_next;}return nullptr;}//哈希删除bool Erase(const K& key){Hash hf;size_t hashi = hf(key) % _tables.size();Node* cur = _tables[hashi];Node* prev = nullptr;while (cur){if (cur->_kv.first == key){if (prev == nullptr){_tables[hashi] = cur->_next;}else{prev->_next = cur->_next;}delete cur;return true ;}prev = cur;cur = cur->_next;}return false;}void Some(){size_t bucketSize = 0;size_t maxBucketLen = 0;size_t sum = 0;double averageBucketLen = 0;for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];if (cur){++bucketSize;}size_t bucketLen = 0;while (cur){++bucketLen;cur = cur->_next;}sum += bucketLen;if (bucketLen > maxBucketLen){maxBucketLen = bucketLen;}}averageBucketLen = (double)sum / (double)bucketSize;printf("all bucketSize:%d\n", _tables.size());printf("bucketSize:%d\n", bucketSize);printf("maxBucketLen:%d\n", maxBucketLen);printf("averageBucketLen:%lf\n\n", averageBucketLen);}private:vector<Node*> _tables;size_t _n = 0;};void TestHT1(){HashTable<int, int> ht;int a[] = { 4,14,24,34,5,7,1,15,25,3 };for (auto e : a){ht.Insert(make_pair(e, e));}ht.Insert(make_pair(13, 13));cout << ht.Find(4) << endl;ht.Erase(4);cout << ht.Find(4) << endl;}void TestHT2(){string arr[] = { "香蕉", "甜瓜","苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };HashTable<string, int> ht;for (auto& e : arr){//auto ret = ht.Find(e);HashNode<string, int>* ret = ht.Find(e);if (ret){ret->_kv.second++;}else{ht.Insert(make_pair(e, 1));}}}//测试效率void TestHT3(){const size_t N = 10000;unordered_set<int> us;set<int> s;HashTable<int, int> ht;vector<int> v;v.reserve(N);srand(time(0));for (size_t i = 0; i < N; ++i){//v.push_back(rand()); // N比较大时，重复值比较多v.push_back(rand() + i); // 重复值相对少//v.push_back(i); // 没有重复，有序}// 21:15size_t begin1 = clock();for (auto e : v){s.insert(e);}size_t end1 = clock();cout << "set insert:" << end1 - begin1 << endl;size_t begin2 = clock();for (auto e : v){us.insert(e);}size_t end2 = clock();cout << "unordered_set insert:" << end2 - begin2 << endl;size_t begin10 = clock();for (auto e : v){ht.Insert(make_pair(e, e));}size_t end10 = clock();cout << "HashTbale insert:" << end10 - begin10 << endl << endl;size_t begin3 = clock();for (auto e : v){s.find(e);}size_t end3 = clock();cout << "set find:" << end3 - begin3 << endl;size_t begin4 = clock();for (auto e : v){us.find(e);}size_t end4 = clock();cout << "unordered_set find:" << end4 - begin4 << endl;size_t begin11 = clock();for (auto e : v){ht.Find(e);}size_t end11 = clock();cout << "HashTable find:" << end11 - begin11 << endl << endl;cout << "插入数据个数：" << us.size() << endl << endl;ht.Some();size_t begin5 = clock();for (auto e : v){s.erase(e);}size_t end5 = clock();cout << "set erase:" << end5 - begin5 << endl;size_t begin6 = clock();for (auto e : v){us.erase(e);}size_t end6 = clock();cout << "unordered_set erase:" << end6 - begin6 << endl;size_t begin12 = clock();for (auto e : v){ht.Erase(e);}size_t end12 = clock();cout << "HashTable Erase:" << end12 - begin12 << endl << endl;}//结果HashTable尽显优势
}

如上便是本期的所有内容了，如果喜欢并觉得有帮助的话，希望可以博个点赞+收藏+关注🌹🌹🌹❤️ 🧡 💛,学海无涯苦作舟,愿与君一起共勉成长

在这里插入图片描述
在这里插入图片描述

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

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【18年扬大真题】定义一个类Student记录学生计算机课程的成绩。要求使用静态成员变量或静态成员函数计算全班学生计算机课程的总成绩和平均成绩

【18年扬大真题】定义一个类Student记录学生计算机课程的成绩。要求使用静态成员变量或静态成员函数计算全班学生计算机课程的总成绩和平均成绩

【18年扬大真题】 定义一个类Student记录学生计算机课程的成绩。要求使用静态成员变量或静态成员函数计算全班学生计算机课程的总成绩和平均成绩 #include<stdio.h> #define n 5;//假设5个学生 typedef struct {char name[10];float score; }stu;int main() {printf(&qu…
阅读更多...
传输层——UDP协议

传输层——UDP协议

文章目录 一.传输层1.再谈端口号2.端口号范围划分3.认识知名端口号4.两个问题5.netstat与iostat6.pidof 二.UDP协议1.UDP协议格式2.UDP协议的特点3.面向数据报4.UDP的缓冲区5.UDP使用注意事项6.基于UDP的应用层协议 一.传输层 在学习HTTP等应用层协议时&#xff0c;为了便于理…
阅读更多...
一起Talk Android吧（第五百五十三回：解析Retrofit返回的数据）

一起Talk Android吧（第五百五十三回：解析Retrofit返回的数据）

文章目录 1. 知识回顾2. 解析方法2.1 解析有效数据2.2 解析错误数据3. 示例代码4. 经验与总结4.1 经验分享4.2 内容总结各位看官们大家好，上一回中咱们说的例子是"Retrofit的基本用法",本章回中介绍的例子是" 如何解析Retrofit返回的数据"。闲话休提，言…
阅读更多...
sqli-labs关卡20(基于http头部报错盲注)通关思路

sqli-labs关卡20(基于http头部报错盲注)通关思路

文章目录 前言一、回顾上一关知识点二、靶场第二十关通关思路1、判断注入点2、爆数据库名3、爆数据库表4、爆数据库列5、爆数据库关键信息 总结 前言 此文章只用于学习和反思巩固sql注入知识&#xff0c;禁止用于做非法攻击。注意靶场是可以练习的平台&#xff0c;不能随意去尚…
阅读更多...
【Spring总结】基于配置的方式来写Spring

【Spring总结】基于配置的方式来写Spring

本篇文章是对这两天所学的内容做一个总结&#xff0c;涵盖我这两天写的所有笔记&#xff1a; 【Spring】 Spring中的IoC&#xff08;控制反转&#xff09;【Spring】Spring中的DI&#xff08;依赖注入&#xff09;Dependence Import【Spring】bean的基础配置【Spring】bean的实…
阅读更多...
gittee启动器

gittee启动器

前言 很多小伙伴反馈不是使用gitee&#xff0c;不会寻找好的项目&#xff0c;在拿到一个项目不知道从哪里入手。 鼠鼠我呀就是宠粉&#xff0c;中嘞&#xff0c;老乡。整&#xff01;&#xff01;&#xff01; git的基本指令 在使用gitee的时候呢&#xff0c;我们只需要记住…
阅读更多...
MSYS2介绍及工具安装

MSYS2介绍及工具安装

0 Preface/Foreword 1 MSYS2 官网&#xff1a;MSYS2
阅读更多...
os.path.join函数用法

os.path.join函数用法

os.path.join()是Python中用于拼接文件路径的函数&#xff0c;它可以将多个字符串拼接成一个路径&#xff0c;并且会根据操作系统的规则自动使用合适的路径分隔符。 注&#xff1a;Linux用的是/分隔符&#xff0c;而Windows才用的是\。 该函数属于os.path模块&#xff0c;因此在…
阅读更多...
CronExpression

CronExpression

CronTrigger配置格式: 格式: [秒] [分] [小时] [日] [月] [周] [年]序号 说明 是否必填 允许填写的值 允许的通配符 1 秒 是 0-59 , - * / 2 分 是 0-59 , - * / 3 小时 是 0-23 , - * / 4 日 是 1-31 , - * ? / L W 5 月 是 1-12 or JA…
阅读更多...
HTTP 到 HTTPS 再到 HSTS 的转变

HTTP 到 HTTPS 再到 HSTS 的转变

近些年&#xff0c;随着域名劫持、信息泄漏等网络安全事件的频繁发生&#xff0c;网站安全也变得越来越重要&#xff0c;也促成了网络传输协议从 HTTP 到 HTTPS 再到 HSTS 的转变。 HTTP HTTP&#xff08;超文本传输协议&#xff09; 是一种用于分布式、协作式和超媒体信息系…
阅读更多...
LeetCode——字符串（Java）

LeetCode——字符串（Java）

字符串 简介[简单] 344. 反转字符串[简单] 541. 反转字符串 II[中等] 151. 反转字符串中的单词 简介 记录一下自己刷题的历程以及代码。写题过程中参考了 代码随想录。会附上一些个人的思路&#xff0c;如果有错误&#xff0c;可以在评论区提醒一下。 [简单] 344. 反转字符串…
阅读更多...
重生之我是一名程序员 34

重生之我是一名程序员 34

哈喽啊大家晚上好&#xff01; 今天给大家带来的知识是——库函数qsort。首先&#xff0c;给大家介绍一下qsort函数&#xff0c; qsort函数是C标准库中的一种排序函数&#xff0c;用于对数组中的元素进行快速排序。它接受四个参数&#xff1a;待排序数组的基地址&#xff0c;数…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023