hash bucket

本文围绕哈希表中的bucket展开,介绍了bucket的英文解释及作用,可解决HASH冲突。探讨了如何确定桶的数量,需在空间和性能间折中。还对比了基于哈希桶和链表实现的差异,前者查表开销可确定,后者可能因冲突严重降低查找效率。
什么是bucket

bucket的英文解释: 

Hash table lookup operations are often O(n/m) (where n is the number of objects in the table and m is the number of buckets), which is close to O(1), especially when the hash function has spread the hashed objects evenly through the hash table, and there are more hash buckets than objects to be stored. 

可以这样理解:

一个HASH的结果所对应的地址可存放两个BUCKET。可解决HASH冲突。 

  • 要存数据时,第一次HASH到这里,在第一个BUCKET存放一个数据。 
  • 要存数据时,当第二次因某些原因HASH到这里时,在第二个BUCKET存放另一个数据。  

一个由5个buckets组成的哈希表,里面有7个元素:

 

linux的hash函数hash_long等,用了golden ratio来计算。因为桶(bits)的数量需要由hash函数和对冲突的期望来决定,那么对于hash_long这样的hash函数,我们怎么确定桶的数量呢? 

一般情况下都是自己根据数据特性来考虑使用的 hash 算法,不是千篇一律咬死一个不放。

比如存放 IP 地址的 hash table,用一个 65536 的桶就很好,把 IP 的后 16bit 作为 key。这种方法绝对比 hash_long、jhash 等函数的碰撞率低。 

其实就是这个界和性能的折中。我可以取我问题空间的最大值。这样肯定能保证键值分散。但是这样会浪费很多空间。然而取得太小,又影响查找效率。感觉还是要在试验中进行测试。而且个人觉得,hash比其他搜索的数据结构灵活的地方就是它的可定制性。可以根据具体情况调整,以达到最优的效果。

 

大致的思路是这样的:

首先哈希桶的个数是固定的,有用户构建的时候输入,一旦构建,个数就已经固定;查找的时候首先将key值通过哈希函数获取哈希值,根据哈希值获取到对应的哈希桶,然后遍历哈希桶内的pairs数组获取;

这两种实现方法看似比较类似,但也有差异:

基于哈希桶的情况下,由于Hash桶容量的限制,所以,有可能发生Hash表填不满的情况,也就是,虽然Hash表里面还有空位,但是新建的表项由于冲突过多,而不能装入Hash表中。不过,这样的实现也有其好处,就是查表的最大开销是可以确定的,因为最多处理的冲突数是确定的,所以算法的时间复杂度为O(1)+O(m),其中m为Hash桶容量。

而另一种通过链表的实现,由于Hash桶的容量是无限的,因此,只要没有超出Hash表的最大容量,就能够容纳新建的表项。但是,一旦发生了Hash冲突严重的情况,就会造成Hash桶的链表过长,大大降低查找效率。在最坏的情况下,时间复杂度退化为O(n),其中n为Hash表的总容量。当然,这种情况的概率小之又小,几乎是可以忽略的。

转载于:https://www.cnblogs.com/austinspark-jessylu/p/9549200.html

template<class T> struct HashBucketNode { T _data; HashBucketNode<T>* _next; HashBucketNode(const T& data) :_data(data) ,_next(nullptr) {} }; // K 为 T 中key的类型 // T 可能是键值对,也可能是K // KeyOfT: 从T中提取key // Hash将key转化为整形,因为哈市函数使用除留余数法 template<class K, class T, class KeyOfT, class Hash> class HashBucket { template<class K, class V, class HF> friend class unordered_map; typedef HashBucketNode<T> Node; typedef HBIterator<K, T, KeyOfT, Hash> Iterator; typedef HBIterator<K, const T, KeyOfT, Hash> const_Iterator; public: HashBucket() { _tables.resize(10, nullptr); } Iterator begin() { for (size_t i = 0; i < _tables.size(); i++) { Node* cur = _tables[i]; if (cur) return { cur,*this }; } return { nullptr,*this }; } Iterator end() { return { nullptr,*this }; } size_t size() { return _n; } bool emptr() { return _n; } // 哈希桶的销毁 ~HashBucket() { for (size_t i = 0; i < _tables.size(); i++) { Node* cur = _tables[i]; while (cur) { Node* next = cur->_next; delete cur; cur = next; } } } /********************************************************************/ /********************************************************************/ unsigned long __stl_next_prime(unsigned long n) { // Note: assumes long is at least 32 bits. static const int __stl_num_primes = 28; static const unsigned long __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 }; const unsigned long* first = __stl_prime_list; const unsigned long* last = __stl_prime_list + __stl_num_primes; const unsigned long* pos = lower_bound(first, last, n); return pos == last ? *(last - 1) : *pos; } /********************************************************************/ // 插入值为data的元素,如果data存在则不插入 pair<iterator, bool> Insert(const T& data) { KeyOfT kot; Hash hash; Iterator it = Find(kot(data)); if (it._pHt) return { it., *this }; if (_n == _tables.size()) { vector<Node*> newTables(__stl_next_prime(_tables.size() + 1), nullptr); for (size_t i = 0; i < _tables.size(); i++) { Node* cur = _tables[cur]; while (cur) { Node* next = cur->_next; size_t hashi = hash(kot(cur->_data)) % newTables.size(); cur->_next = newTables[hashi]; newTables[hashi] = cur; cur = next; } _tables[hashi] = nullptr; } _tables.swap(newTables); } size_t hashi = hash(kot(data)) % _tables.size(); Node* newnode = new Node(data); newnode->_next = _tables[hashi]; _tables[hashi] = newnode; ++_n; return { iterator{ newnode,*this }, ture }; } // 在哈希桶中查找值为key的元素,存在返回true否则返回false iterator Find(const K& key) { KeyOfT kot; Hash hash; size_t hashi = hash(key) % _tables.size(); Node* cur = _tables[hashi]; while (cur) { if (kot(cur->_data) == key) { return { cur,*this }; } cur = cur->_next; } return { nullptr,*this }; } // 哈希桶中删除key的元素,删除成功返回true,否则返回false bool Erase(const K& key) { KeyOfT kot; Hash hash; size_t hashi = hash(key) % _tables.size(); Node* cur = _tables[hashi]; Node* prev = nullptr; while (cur) { if (kot(cur->_data) == key) { if (prev == nullptr) { _tables[hashi] = nullptr; } else { prev->_next = cur->_next; delete cur; --_n; return true; } } prev = cur; cur = cur->_next; } return false; } Iterator Erase(Iterator position) { KeyOfT kot; Iterator it = Find(kot(position.)) if() } private: vector<Node*> _tables; // 指针数组 size_t _n = 0; // 表中存储数据个数 };编写下面namespace bit { // 为了实现简单,在哈希桶的迭代器类中需要用到hashBucket本身, template<class K, class V, class KeyOfValue, class HF> class HashBucket; // 注意:因为哈希桶在底层是单链表结构,所以哈希桶的迭代器不需要--操作 template <class K, class V, class KeyOfValue, class HF> struct HBIterator { typedef HashBucket<K, V, KeyOfValue, HF> HashBucket; typedef HashBucketNode<V>* PNode; typedef HBIterator<K, V, KeyOfValue, HF> Self; HBIterator(PNode pNode = nullptr, HashBucket* pHt = nullptr); Self& operator++() { // 当前迭代器所指节点后还有节点时直接取其下一个节点 if (_pNode->_pNext) _pNode = _pNode->_pNext; else { // 找下一个不空的桶,返回该桶中第一个节点 size_t bucketNo = _pHt->HashFunc(KeyOfValue()(_pNode->_data))+1; for (; bucketNo < _pHt->BucketCount(); ++bucketNo) { if (_pNode = _pHt->_ht[bucketNo]) break; } } return *this; } Self operator++(int); V& operator*(); V* operator->(); bool operator==(const Self& it) const; bool operator!=(const Self& it) const; PNode _pNode; // 当前迭代器关联的节点 HashBucket* _pHt; // 哈希桶--主要是为了找下一个空桶时候方便 }; // unordered_map中存储的是pair<K, V>的键值对,K为key的类型,V为value的类型,HF哈希函数类型 // unordered_map在实现时,只需将hashbucket中的接口重新封装即可 template<class K, class V, class HF = DefHashF<K>> class unordered_map { typedef HashBucket<K, pair<K, V>, KeyOfValue, HF> HT; // 通过key获取value的操作 struct KeyOfValue { const K& operator()(const pair<K, V>& data) { return data.first;} }; public: typename typedef HT::Iterator iterator; public: unordered_map(): _ht() {} //////////////////////////////////////////////////// iterator begin(){ return _ht.begin();} iterator end(){ return _ht.end();} //////////////////////////////////////////////////////////// // capacity size_t size()const{ return _ht.size();} bool empty()const{return _ht.empty();} /////////////////////////////////////////////////////////// // Acess V& operator[](const K& key) { pair<iterator, bool> ret = _ht.InsertUnique(pair<K, V>(key, V())); return ret.fisrt->second; } const V& operator[](const K& key)const; ////////////////////////////////////////////////////////// // lookup iterator find(const K& key){ return _ht.Find(key);} size_t count(const K& key){ return _ht.Count(key);} ///////////////////////////////////////////////// // modify pair<iterator, bool> insert(const pair<K, V>& valye) { return _ht.Insert(valye);} iterator erase(iterator position) { return _ht.Erase(position);} //////////////////////////////////////////////////////////// // bucket size_t bucket_count(){ return _ht.BucketCount();} size_t bucket_size(const K& key){ return _ht.BucketSize(key);} private: HT _ht; }; }
最新发布
07-10
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值