文章目录
一、unordered_set、unordered_map的介绍
1.unordered_set、unordered_map的底层是哈希表，哈希表是一种关联式容器（与前面的二叉搜索树、AVL树、红黑树一样，数据与数据之间有很强的关联性）
2.单向迭代器（map、set是双向迭代器）
3.哈希表的查找顺序是O（1），性能比红黑树（logn）好一些（在数据接近与有序的情况下与哈希表一样）。
二、哈希表的建立方法
2.1闭散列
缺点：值很分散，直接定址会导致空间开很大，浪费。
2.2开散列（哈希桶/拉链法）
除留余数法会发生哈希碰撞（关键字可以很分散，量可以很大，关键字-存储位置是多对一的关系，存在哈希冲突）：不同的值映射到相同的位置上去。
负载因子（存储数据的个数/表的大小，也就是空间的占用率）：存储关键字的个数/空间大小
三、闭散列代码（除留余数法）
cpp
#pragma once
#include<iostream>
#include<vector>
#include<string>
using namespace std;
template<class K>
struct HashFunc
{
size_t operator()(const K& key)
{
return key;
}
};
template<>
struct HashFunc<string>
{
size_t operator()(const string& kv)
{
size_t hashi = 0;
for (auto e : kv)
{
hashi *= 31;
hashi += e;
}
return hashi;
}
};
namespace close
{
enum Status
{
EMPTY,
EXIST,
DELETE
};
template<class K,class V>
struct HashData
{
pair<K, V> _kv;
Status _s;//表示状态
};
template<class K,class V,class Hash = HashFunc<K>>
class HashTable
{
public:
typedef HashData<K, V> data;
HashTable()
{
_tables.resize(10);
}
data* find(const K key)
{
size_t hash = key % _tables.size();
while (_tables[hash]._s!=EMPTY)
{
if (_tables[hash]._s == EXIST && _tables[hash]._kv.first == key)
return &_tables[hash];
hash++;
hash %= _tables.size();
}
return nullptr;
}
bool insert(const pair<K,V>& kv)
{
Hash hf;
if (find(kv.first))
return false;
if (_n * 10 / _tables.size() == 7)
{
//建新表
HashTable<K,V,Hash> newtable;
newtable._tables.resize(_tables.size() * 2);
for (size_t i = 0; i < _tables.size(); i++)
{
if (_tables[i]._s == EXIST)
newtable.insert(_tables[i]._kv);
}
_tables.swap(newtable._tables);
}
size_t hash = hf(kv.first) % _tables.size();
//线性探测
while (_tables[hash]._s != EMPTY)
{
hash++;
hash %= _tables.size();
}
_tables[hash]._kv = kv;
_tables[hash]._s = EXIST;
_n++;
return true;
}
bool erase(const K& key)
{
data* ret = find(key);
if (ret)
{
_n--;
ret->_s == DELETE;
return true;
}
return 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<data> _tables;
size_t _n = 0;
};
}四、开散列代码（拉链法/哈希桶）
cpp
namespace hash_bucket
{
template<class K,class V>
struct HashNode
{
pair<K, V> _kv;
HashNode<K, V>* _next;
};
template<class K,class V,class Hash = HashFunc<K>>
class HashTable
{
public:
typedef HashNode<K, V> Node;
HashTable()
{
_tables.resize(10, nullptr);
}
~HashTable()
{
for (size_t i = 0; i < _tables.size(); i++)
{
Node* cur = _tables[i];
if (cur)
{
Node* next = cur->_next;
delete cur;
cur = next;
}
_tables[i] = nullptr;
}
}
Node* find(const K& key)
{
Hash hf;
size_t hash = hf(key) % _tables.size();
Node* cur = _tables[hash];
while (cur)
{
if (hf(cur->_kv.first) == hf(key))
return cur;
cur = cur->_next;
}
return nullptr;
}
bool insert(pair<K,V>& kv)
{
Hash hf;
if (find(kv.first))
return false;
if (_bucket == _tables.size())
{
HashTable newtable;
newtable._tables.resize(_tables.size() * 2, nullptr);
for (size_t i = 0; i < _tables.size(); i++)
{
Node* cur = _tables[i];
while (cur)
{
size_t hash = hf(cur->_kv.first) % newtable._tables.size();
cur->_next = newtable._tables[hash];
newtable._tables[hash] = cur;
cur = cur->_next;
}
}
_tables.swap(newtable._tables);
}
size_t hash = hf(kv.first) % _tables.size();
Node* cur = new Node(kv);
cur->_next = _tables[hash];
_tables[hash] = cur;
_bucket++;
return true;
}
bool erase(const K& key)
{
Hash hf;
size_t hash = hf(key) % _tables.size();
Node* cur = _tables[hash];
Node* prev = nullptr;
while (cur)
{
if (hf(key) == hf(_tables[hash]->_kv.first))
{
_tables[hash] = cur->_next;
delete cur;
return true;
}
else
{
if (hf(key) == hf(cur->_kv.first))
{
prev->_next = cur->_next;
delete cur;
return true;
}
prev = cur;
cur = cur->_next;
}
}
_bucket--;
return false;
}
private:
vector<Node*> _tables;
size_t _bucket = 0;
};
}代码解读：这里的插入节点是头插（效率高一些）