C++模拟实现unordered_map和unordered_set
unordered系列
- unordered_map是存储
- 在内部unordered_map将相同哈希值的键值对放在相同的桶中。键值通常用于惟一地标识元素，而映射值是一个对象，其内容与此键关联。键和映射值的类型可能不同。
- unordered_map容器通过key访问单个元素要比map快，map是用红黑树实现的，时间复杂度为lgN。但unordered_map通常在遍历元素子集的范围迭代方面效率较低。
- unordered_set是存储< key >的关联式容器，它不支持operator[]操作，其他操作和unoredred_map类似，底层结构也都是相同的。
底层结构
- unordered系列的关联式容器之所以效率比较高，是因为其底层使用了哈希结构。
- 这里我使用开散列解决哈希冲突问题。
- 开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。
完整代码请前往GitHub—>点我啊
HashBucket.hpp
#pragma once
#includeUnordered_map.hpp
#pragma once
#include"HashBucket.hpp"
template<class K,class V>
class Unordered_map {
typedef std::pair<K, V> ValueType;
typename typedef HashBucket<ValueType, KORV>::iterator iterator;
struct KORV
{
const K& operator()(const ValueType& data)const {
return data.first;
}
};
public:
Unordered_map(size_t size = 11)
:_ht(size)
{}
iterator begin(){
return _ht.begin();
}
iterator end(){
return _ht.end();
}
bool empty()const {
return _ht.empty();
}
size_t size()const {
return _ht.size();
}
std::pair<iterator,bool> insert(const ValueType& data){
return _ht.Insert(data);
}
size_t erase(const K& key){
return _ht.Erase(ValueType(key,V()));
}
iterator find(const K& key) const{
return _ht.find(ValueType(key, V()));
}
void clear() {
_ht.Clear();
}
void swap(const Unordered_map<K,V>& m) {
_ht.Swap(m._ht);
}
V& operator[](const K& k) {
return (*(insert(ValueType(k, V())).first)).second;
}
size_t buck_count()const {
return _ht.bucket_count();
}
size_t buck_size(size_t n)const {
return _ht.bucket_size(n);
}
size_t bucket(const K& k) {
return _ht.bucket(ValueType(k, V()));
}
private:
HashBucket<ValueType, KORV> _ht;
};
Unordered_set.hpp
#pragma once
#include"HashBucket.hpp"
template<class K>
class Unordered_set {
typedef K ValueType;
typename typedef HashBucket<ValueType, KORV>::iterator iterator;
struct KORV
{
const ValueType& operator()(const ValueType& data)const {
return data;
}
};
public:
Unordered_set(size_t size = 11)
:_ht(size)
{}
iterator begin() {
return _ht.begin();
}
iterator end() {
return _ht.end();
}
bool empty()const {
return _ht.empty();
}
size_t size()const {
return _ht.size();
}
std::pair<iterator, bool> insert(const ValueType& data) {
return _ht.Insert(data);
}
size_t erase(const ValueType& key) {
return _ht.Erase(key);
}
iterator find(const ValueType& key) const {
return _ht.find(key);
}
void clear() {
_ht.Clear();
}
void swap(const Unordered_set<K>& m) {
_ht.Swap(m._ht);
}
size_t buck_count()const {
return _ht.bucket_count();
}
size_t buck_size(size_t n)const {
return _ht.bucket_size(n);
}
size_t bucket(const ValueType& k) {
return _ht.bucket(k);
}
private:
HashBucket<ValueType, KORV> _ht;
};