【STL】哈希表 {unordered系列容器的介绍和使用；模拟实现unordered_set和unordered_map}

已于 2024-07-25 13:41:47 修改
阅读量494 收藏 1
点赞数 1
分类专栏： C++ 文章标签： 哈希算法 散列表 数据结构
于 2023-09-23 12:47:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zty857016148/article/details/133203262
版权

一、unordered系列关联式容器

在C++98中，STL提供了底层为红黑树结构的一系列关联式容器map/set，在查询时效率可达到log_2N，即最差情况下需要比较红黑树的高度次。

在C++11中，STL又提供了4个unordered系列的关联式容器：unordered_map、unordered_multimap、unordered_set、unordered_multiset。这四个容器与红黑树结构的关联式容器相比查询效率更高接近于O(1)，且使用方式基本类似，只是其底层结构不同。

1.1 unordered_map

  1. unordered_map是存储<key, value>键值对的关联式容器，其允许通过key快速的索引到与其对应的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_map的迭代器是前向迭代器(Forward Iterator)。

1.1.1 reserve & rehash

在这里插入图片描述

当谈到hash表时，"reserve"和"rehash"是两个常用的术语。它们之间的主要区别如下：

  1. Reserve: 在reserve中，我们为hash表分配足够的内存空间来容纳未来可能要插入的元素。这样做可以减少因为表的大小不够而导致的rehash操作。在C++中，我们可以使用reserve()函数来分配内存空间。

  2. Rehash: 当hash表中的元素个数超过了负载因子（load factor）所规定的阈值，就需要进行rehash操作。在rehash过程中，hash表的大小被加倍，并且所有元素被按照新的哈希函数重新插入到新的桶中。这样做可以避免哈希碰撞并提高性能。

1.2 unordered_set

  1. unordered_set是不按特定顺序存储唯一元素key的容器，并允许根据key值快速检索单个元素。
  2. 在unordered_set中，元素的键值key唯一标识它。键是不可变的，因此，unordered_set中的元素不能在容器中修改，但是可以插入和删除它们。
  3. 在内部，unordered_set中的元素不按任何特定顺序排序。为了能在常数时间内按其key快速访问单个元素，unordered_set将相同哈希值的元素放在相同的桶中。
  4. unordered_set容器比set容器更快地通过其key访问单个元素，但它通常在遍历元素子集的范围迭代方面效率较低。
  5. unordered_set的迭代器是前向迭代器(Forward Iterator)。

1.3 与红黑树结构map/set的区别

  1. map/set的遍历是有序的，而unordered系列是无序的。
  2. map/set的迭代器是双向迭代器，而unordered系列是单向的。
  3. 在面对大量数据时，unordered系列的查找效率更高
  4. unordered系列的关联式容器之所以效率比较高，是因为其底层使用了哈希结构。
  5. 对比哈希表和红黑树：请转到 2.3.2 开散列

二、模拟实现unordered_map & unordered_set

2.1 核心结构

//数据节点的结构
template <class T>
struct HashNode{
  typedef HashNode<T> Node;
  T _data; //泛型底层哈希表的存储类型，通过不同的实例化参数，实现出unordered_map和unordered_set。
  Node *_next; //指向下一个节点的指针

  HashNode(const T& data = T(), Node *next = nullptr)
    :_data(data),
    _next(next)
  {}
};

//默认哈希算法
template <class K>
struct Hashkey{
  size_t operator()(const K& key){
    return (size_t)key;
  }
};

template <>
struct Hashkey<string>{
  size_t operator()(const string& str){
    size_t ret = 0;
    for(char e : str)
    {
      ret += e;
      ret *= 131;
    }
    return ret;
  }
};

//哈希表的结构（哈希桶）
template <class K, class T, class Hash, class KofT>
class HashTable{
  typedef HashNode<T> Node;
  vector<Node*> _table; //数组存放指向节点的指针
  size_t _size = 0;
  //将迭代器设为友元类，注意类模版要带模版参数
  template <class k, class t, class hash, class kofT>
  friend class __Hashiterator;

public:
  //迭代器
  typedef __Hashiterator<K, T,Hash,KofT> iterator;
    
  iterator begin(){
    for(int i=0; i<_table.size(); ++i)
    {
      if(_table[i] != nullptr)
        return iterator(_table[i], this);
    }
    return end();
  }

  iterator end(){
    return iterator(nullptr, this);
  }
    
  //析构函数
  ~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;
	}
  }
    
  //查找、插入、删除
  iterator find(const K& key);
  pair<iterator, bool> insert(const T& data);
  bool erase(const K& key);

  size_t size(){
    return _size;
  }

private:
  //__stl_next_prime用于获取下一个大于n的质数作为扩容后的容量
  size_t __stl_next_prime(size_t n);
};

2.2 迭代器

//前置声明
template <class K, class T, class Hash, class KofT>
class HashTable;

template <class K, class T, class Hash, class KofT>
class __Hashiterator{
  typedef HashNode<T> Node;
  typedef HashTable<K,T,Hash,KofT> HT;
  typedef __Hashiterator<K,T, Hash, KofT> iterator;
  Node *_pnode; //指向数据节点的指针
  HT *_pht; //指向哈希表对象的指针

public:
  __Hashiterator(Node *pnode, HT *pht)
    :_pnode(pnode),
    _pht(pht)
  {}

public:
  T& operator*() const{
    return _pnode->_data;
  }

  T* operator->() const{
    return &_pnode->_data;
  }

  bool operator==(const iterator& it) const{
    return it._pnode == _pnode;
  }

  bool operator!=(const iterator& it) const{
    return it._pnode != _pnode;
  }

  iterator& operator++(){
    if(_pnode->_next != nullptr)
    {
      //在当前桶中迭代
      _pnode = _pnode->_next;
    }
    else
    {
      //找下一个桶
      KofT kot;
      Hash hash;
      size_t hashi = hash(kot(_pnode->_data)) % _pht->_table.size();
      int i = hashi + 1;
      for(; i<_pht->_table.size(); ++i)
      {
        if(_pht->_table[i] != nullptr)
        {
          _pnode = _pht->_table[i];
          break;
        }
      }
      //如果后面没有有数据的桶了
      if(i == _pht->_table.size())
        _pnode = nullptr;
    }
    return *this;
  }

  iterator operator++(int){
    iterator it(*this);
    ++*this;
    return it;
  }
};

2.3 查找、插入、删除

2.3.1 find

  iterator find(const K& key){
    if(_table.size() == 0)
      return end();
    
    Hash hash;
    KofT kot;
    size_t hashi = hash(key) % _table.size();
    Node *cur = _table[hashi];
    while(cur != nullptr)
    {
      if(kot(cur->_data) == key)
      {
        return iterator(cur, this);
      }
      cur = cur->_next;
    }
    return end();
  }

2.3.2 insert && __stl_next_prime

  pair<iterator, bool> insert(const T& data){
    KofT kot;
    Hash hash;
    //去重
    iterator ret = find(kot(data));
    if(ret != end())
        return make_pair(ret, false);
    //扩容
    //当载荷因子为1时进行扩容
    if(_size == _table.size())
    {
      //获取大于_table.size()的下一个质数作为新容量
      size_t newsize = __stl_next_prime(_table.size()); 
      //创建新数组
      vector<Node*> newtable;
      newtable.resize(newsize);
      //计算元素在新表中的哈希地址，并将节点移动到新表
      for(size_t i=0; i<_table.size(); ++i)
      {
        Node *cur = _table[i];
        Node *next = nullptr; //用于记录cur->_next
        while(cur != nullptr)
        {
          size_t hashi = hash(kot(cur->_data)) % newsize;
          next = cur->_next;
          //将节点头插到新表的对应桶中
          cur->_next = newtable[hashi]; 
          newtable[hashi] = cur;
          cur = next;
        }
        //最后将旧表中的桶置空，防止析构时释放新表中的节点
        _table[i] = nullptr;
      }
      //交换新旧两表
      swap(_table, newtable);
    }
    //插入
    size_t hashi = hash(kot(data)) % _table.size();
    Node *newnode = new Node(data);
    newnode->_next = _table[hashi];
    _table[hashi] = newnode;
    ++_size;
    return make_pair(iterator(newnode, this), true);
  }

private:
  //__stl_next_prime用于获取下一个大于n的质数作为扩容后的容量
  inline size_t __stl_next_prime(size_t n)
  {
    //预置一个质数表，从表中依次取质数作为扩容后的容量
    static const int __stl_num_primes = 28;
    static const size_t __stl_prime_list[__stl_num_primes] =
    {
      53,         97,         193,       389,       769,
      1543,       3079,       6151,      12289,     24593,
      49157,      98317,      196613,    393241,    786433,
      1572869,    3145739,    6291469,   12582917,  25165843,
      50331653,   100663319,  201326611, 402653189, 805306457, 
      1610612741, 3221225473, 4294967291
    };
    for(int i=0; i<__stl_num_primes; ++i)
    {
      if(__stl_prime_list[i] > n)
      {
        return __stl_prime_list[i];
      }
    }
    return -1;
  }

为什么选择质数作为哈希表容量的大小？

  • 选择质数作为哈希表容量的大小，原因是在hash函数中你要用这些质数来做模运算(%)。
  • 而分析发现，如果容量选择为非质数，例如选择一个合数（除了1和自身外还有其他因数的数），那么容易出现多个键映射到同一个索引的情况，导致哈希表性能下降。
  • 所以这里最后采用了质数做模的除数。质数的选择可以使哈希函数更均匀地分布键值，减少碰撞的概率。

2.3.3 erase

  bool erase(const K& key){
    //空表删除返回false
    if(_table.size() == 0)
      return false;

    Hash hash;
    KofT kot;
    size_t hashi = hash(key) % _table.size();
    Node *cur = _table[hashi];
    Node *prev = nullptr; //记录cur的前驱节点便于删除节点前进行连接
    while(cur != nullptr)
    {
      //找到进行删除
      if(key == kot(cur->_data))
      {
        //如果删除的是头结点
        if(cur == _table[hashi])
          _table[hashi] = cur->_next;
        else
          prev->_next = cur->_next;
        delete cur; 
        --_size; //不要忘了修改_size
        return true;
      }
      prev = cur;
      cur = cur->_next;
    }
    //找不到返回false
    return false;
  }

set和unordered_set的key类型(K)分别有什么要求？

  • set中的key类型：

    在这里插入图片描述

    • 要求支持小于比较(默认less)，或者提供小于或大于的比较仿函数(class Compare)
    • 小技巧：小于反过来使用就是大于：a<b小于 b<a大于 else等于

  • unordered_set中的key类型：

    在这里插入图片描述

    • 要求支持整型转换，或者提供整型转换仿函数(class Hash)
    • 要求支持等于比较，或者提供等于比较的仿函数(class Pred)

提示：模拟实现代码中没有体现unordered_set的等于比较仿函数(class Pred)。

2.4 unordered_set封装

#pragma once
#include "HashTable.hpp"

namespace zty{

  template <class K, class Hash = Hashkey<K>>
  class unordered_set{
    struct SetKofT{
      const K& operator()(const K& key){
        return key;
      }
    };

    typedef HashNode<K> Node;
    typedef HashTable<K, K, Hash, SetKofT> HT;
    HT _ht;

  public:
    typedef typename HT::iterator iterator;

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

    size_t size(){
      return _ht.size();
    }

    pair<iterator, bool> insert(const K& key){
      return _ht.insert(key);
    } 

    iterator find(const K& key){
      return _ht.find(key);
    }

    bool erase(const K& key){
      return _ht.erase(key);
    }
  };
}

2.5 unordered_map封装

#pragma once
#include "HashTable.hpp"

namespace zty
{
  template <class K, class V, class Hash = Hashkey<K>>
  class unordered_map{
    struct MapKofT{
      const K& operator()(const pair<K,V>& kv){
        return kv.first;
      }
    };
    typedef HashTable<K,pair<K,V>,Hash,MapKofT> HT;
    HT _ht;

  public:
    typedef typename HT::iterator iterator;
    iterator begin(){
      return _ht.begin();
    }
    iterator end(){
      return _ht.end();
    }

    pair<iterator, bool> insert(const pair<K,V>& kv){
      return _ht.insert(kv);
    }

    //重载operator[]
    V& operator[](const K& key){
      auto ret = _ht.insert(make_pair(key, V()));
      return ret.first->second;
    }

    iterator find(const K& key){
      return _ht.find(key);
    }

    bool erase(const K& key){
      return _ht.erase(key);
    }
  };
}
芥末虾
关注
专栏目录
C++ 使用哈希表封装模拟实现unordered_map unordered_set
TPON的博客
11-17 842
C++实现哈希表封装unordered_map unordered_set
C++ STL 中哈希表的详细用法
TheJustice_的博客
07-01 1003
C++ STL 中的和提供了强大的哈希表功能，能够高效地进行插入、删除和查找操作。理解其用法和注意事项，能够帮助我们在实际开发中更好地利用这些容器。
哈希表应用C++_STL_hash
12-14
哈希表应用C++_STL_hash 哈希表应用C++_STL_hash 哈希表应用C++_STL_hash
【STL】哈希表（概念讲解、底层实现、unordered_map/set封装）
最新发布
2302_80023639的博客
08-22 980
首先我们需要明白的是，哈希是一种思想正常情况下，我们在面对一些算法题的时候，如果数据范围较小，比如英文26个字母小写，这种情况下我们就可以直接开一个简单数据，让每一个字母代表一个位置，这叫做映射而我们的哈希表，是一种数据结构，是用来处理那些数据范围很大但是数据量不一定大的情况假设我们存了一组数：1，331，200000，630我们能看到，这只有四个数，但是范围却是1~2000000，所以我们就会用到哈希表。
stl之哈希表
IOT_SHUN的博客
03-15 305
hash_map基于hash table（哈希表）。 哈希表最大的优点，就是把数据的存储和查找消耗的时间大大降低，几乎可以看成是常数时间；而代价仅仅是消耗比较多的内存...
stl哈希表
qq_59144780的博客
02-07 34
·
C++ STL --哈希表
cat_fish_rain的博客
07-01 2811
在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到$log_2N$，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11中，STL又提供了4个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同，本文中只对和进行介绍，和学生可查看文档介绍。是存储键值对的关联式容器，其允许通过keys。
STL之哈希表
--- 自由在高处
03-14 686
unordered_map、unordered_set用法unordered_map列举出几个主要的unordered_map的函数，并用程序列子说明：1、unordered_map::count#include "iostream" #include "vector" #include "string" #include "queue" #include "algorithm" #include
C++中的哈希容器unordered_map使用示例
12-31
很久以来，STL中都只提供<map>作为存放对应关系的容器，内部通常用红黑树实现，据说原因是二叉平衡树（如红黑树）的各种操作，插入、删除、查找等，都是稳定的时间复杂度，即O(log n)；但是对于hash表来说，由于无法...
unordered_map_unordered_map_
09-29
在C++编程语言中，`unordered_map`是一个非常重要的容器，属于STL（标准模板库）的一部分。这个容器提供了一种高效的方式来进行键值对（key-value pairs）的存储和检索，类似于字典或者哈希表。在本实例中，我们将...
C++ STL(八) -------- unordered_set、unordered_map的介绍+使用+比较
向未来❀去探索 的博客
09-04 1559
unordered_set、unordered_map的介绍+使用+比较
侯捷C++ STL：哈希表（unordered_set,unordered_multiset,unordered_map,unordered_multimap）的底层实现
weixin_39770712的博客
11-09 899
哈希表的产生由于内存不够一一映射。于是乎在空间不足时取余数。 为了防止某一个链表过长，这里根据经验来制定规则。当插入的元素个数等于buckets时这时哈希表要扩容。扩容因子是两倍。但是buckets值尽量是质数，选择质数是为了尽量做到均匀散列。所以扩容后要找两倍大后附近的质数。编译器将空间扩容的空间大小都自己定义好了，不用重新计算空间，53-97-193…。 底层实现： HashFcn：一个对象如何映射为一个号码/编号。hasher,key_equal,ExtractKey是function objec
第六课:哈希表,STL
weixin_64197656的博客
05-16 458
一、哈希表 哈希表是将大范围数据映射到小范围的存储方式。映射需要设定一个哈希函数。有常规数字哈希以及字符串哈希。 1.数字哈希 数字哈希的哈希函数是（x%N+N）%N，并且要去N是质数，以减少冲突的情况。对于整数就就是直接模N，但是考虑让负数模N和整数的值一样，需要改成这个样子。 映射后，可能有多个数字被映射成相同的k值，那么需要处理冲突。常见方法有开放寻址法和拉链法。 （1）拉链法 拉链法顾名思义，在每个k值上拉出一条链表，由链表存储映射到这个k值上的x值。 #include.
C++STL哈希表
qq_62745420的博客
10-08 2062
哈希算法是如何不通过比较就能确定一个数据在不在呢？答案是：通过将数据插入的位置与关键字建立映射关系，这种映射关系就是后面要说到的哈希函数简单举个例子：现在有这样一个场景，给你了一个长度为N的字符串，需要你在O（N）的时间复杂度内找出所有只出现过一次的字符。这时候我们就可使用哈希算法中的直接定址法来解决。什么是直接定址法呢？就是我们创建一个长度为128的计数数组，然后用字符的ascii码值直接映射到数组的这个位置，对这个位置进行++。
深剖STL——哈希表（内含unordered_map和unordered_set模拟实现）
辰多代码的博客
03-26 1706
哈希（Hash）是指将任意长度的输入通过哈希函数（Hash Function）转换为固定长度的输出的过程。哈希函数可以将输入数据映射为较短的固定长度的值，通常用一串数字和字母来表示，这串值就被称为哈希值或者哈希码。输入相同的数据经过哈希函数得到的哈希值是唯一确定的。即使输入数据只有微小的改动，得到的哈希值也会发生很大的变化。无法从哈希值中逆向推导出原始的输入数据。
算法之路：c++STL 哈希表
wzc200406的博客
05-08 390
是一个模板类，用于定义哈希表，其中Key是键类型，T是值类型，Hash是哈希函数的类型，Pred是键比较函数的类型，Alloc是分配器类型。在定义时，可以省略其中的一些参数，因为它们都有默认值。
STL中的哈希表 hash table
Yaphets__2015的博客
11-28 140
哈希表在STL的map库中，用到的两个主要函数为map.count()和map.insert()，分别是查找和插入操作。代码样例如下： 1 include <map> 2 3 map<int, int> hashtable; 4 if(!hashtable.count(key)) { 5 hashtable.insert(pair<i...
C++ STL源码剖析之哈希表Hashtable
白话机器学习
07-19 244
内部结构为在每个元素中维护一个单链表, 然后在单链表上执行元素的插入、搜寻、删除等操作，每个元素被称为桶(bucket)，底层构建先采用H1计算出key的hash code，再通过除留余数法H2得到其对应的桶。中找到了所有的素数表。这次阅读的代码仍旧是gcc4.9.1，代码量非常多，就不全部展开，重点研究底层哈希的艺术与技术，似乎这两个词语很押韵哦，哈哈，进入正文～到这里就很明确了，对于节点，分为包含hash code与不包含，具体是根据传递的模板参数，来调用相应的偏特化版本。
＜stl系列＞哈希表详解，掌握stl容器从现在开始
weixin_59371851的博客
09-22 1994
哈喽，小伙伴们大家好，今天我们来学习几个新的容器。这几个容器存储和查找数据效率是非常高的，能达到非常理想的O(1)，这主要因为它们采用了哈希的思想。那么事不宜迟，我们一起来看看吧。一、unordered系列关联式容器c++中容器分为序列式容器和关联式容器。所谓序列容器，就是以线性排列来排列某种类型的数据，比如vect，list，dequene。序列式容器通常只是单纯的用来存储数据。
unordered_map和unordered_set是否使用的哈希表
05-24
是的，unordered_map和unordered_set都使用哈希表实现。哈希表是一种高效的数据结构，可以快速地进行插入、查找和删除操作。在C++ STL中，unordered_map和unordered_set都是通过哈希表来实现的。具体来说，unordered_map使用哈希表来存储键值对，而unordered_set只存储关键字，不存储值。不同的关键字使用哈希函数进行映射，并被存储在哈希表中的不同位置。这样，我们可以通过关键字的哈希值来快速定位到对应的位置，从而实现快速的查找和插入操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

芥末虾

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值