文章目录
哈希概念
顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O(log2N)，搜索的效率取决于搜索过程中元素的比较次数。
理想的搜索方法：不经过任何比较，一次直接从表中得到要搜索的元素。 如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。
当向该结构中:
-
插入元素
根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
-
搜索元素
对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功
该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表 (Hash Table)(或者称散列表)
例如：数据集合{1，7，6，4，5，9};
哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。
用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快。 问题：按照上述哈希方式，向集合中插入元素44，会出现什么问题?（哈希冲突）
哈希冲突
对于两个数据元素的关键字ki和 kj(i != j)，有 ki != kj ，但有：Hash( ki ) == Hash( kj )，即：不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。
把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。 发生哈希冲突该如何处理呢?
哈希函数
引起哈希冲突的一个原因可能是：哈希函数设计不够合理。 哈希函数设计原则:
-
哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0 到m-1之间
-
哈希函数计算出来的地址能均匀分布在整个空间中
-
哈希函数应该比较简单
常见哈希函数
- 直接定制法
取关键字的某个线性函数为散列地址:Hash(Key)= A*Key + B
- 优点：简单、均匀
- 缺点：需要事先知道关键字的分布情况 使用场景:适合查找比较小且连续的情况
- 除留余数法
设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址
- 平方取中法
假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址; 再比如关键字为 4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址
平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况
- 折叠法
折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。
折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况
- 随机数法
选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key)，其中random为随机数函数。
通常应用于关键字长度不等时采用此法
- 数学分析法
设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。例如:
假设要存储某家公司员工登记表，如果用手机号作为关键字，那么极有可能前7位都是相同的，那么我们可以选择后面的四位作为散列地址，如果这样的抽取工作还容易出现冲突，还可以对抽取出来的数字进行反转(如1234改成4321)、右环位移(如1234改成4123)、左环移位、前两数与后两数叠加(如1234改 成12+34=46)等方法。
数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况
注意:哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突
哈希冲突解决
闭散列
也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个” 空位置中去。 那如何寻找下一个空位置呢?
- 线性探测
比如
现在需要插入元素44，先通过哈希函数计算哈希地址，hashAddr为4，因此44理论上应该插在该位置，但是该位置已经放了值为4的元素，即发生哈希冲突。
线性探测:从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。
-
插入
通过哈希函数获取待插入元素在哈希表中的位置
如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素
- 删除
采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如删除元素4，如果直接删除掉，44查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。
// 哈希表每个空间给个标记
// EMPTY此位置空， EXIST此位置已经有元素， DELETE元素已经删除
enum State{EMPTY, EXIST, DELETE};
什么时机增容，如何增容?
线性探测的实现
#pragma once
#include <map>
#include <vector>
using namespace std;
namespace dg {
enum State {
EMPTY,
EXIST,
DELETE
};
// 整形数据不需要转化
class dealInt
{
public:
int operator()(int n)
{
return n;
}
};
// key为字符串类型，需要将其转化为整形
class dealString
{
public:
int operator()(const string& n)
{
int sum = 0;
int seed = 131; // 131进制
for (const char& c : n)
{
sum = sum * seed + c;
}
return sum & 0x7FFFFFFF; // 为了保证得到的index的第一位为0，也就是为了得到一个正数。
}
};
template<class K, class V, class SW = dealInt>
class hashTable
{
struct elem
{
pair<K, V> m_val;
State m_state;
elem(const K& key = K(), const V& val = V(), State state = EMPTY) :
m_val(key, val),
m_state(state)
{}
};
vector<elem> m_table;
size_t m_size;
static long long s_m_primeTable[30];
int m_primePos;
public:
hashTable(size_t capacity = s_m_primeTable[0]) :
m_table(capacity),
m_size(0),
m_primePos(0)
{}
size_t capacity()
{
return m_table.size();
}
private:
int hashFunc(const K& key)
{
SW func;
return func(key) % capacity();
}
void reserve()
{
vector<elem> tmp;
m_table.swap(tmp);
m_table.resize(s_m_primeTable[++m_primePos]);
m_size = 0;
for (auto& e : tmp)
{
if (e.m_state == EXIST)
{
insert(e.m_val);
}
}
}
public:
bool insert(const pair<K, V>& val)
{
if ((long long)size() * 100 / capacity() >= 75)
{
reserve();
}
int n = hashFunc(val.first);
while (m_table[n].m_state == EXIST)
{
if (m_table[n].m_val.first == val.first)
{
return false;
}
n++;
if (n == capacity())
{
n = 0;
}
}
m_table[n].m_val = val;
m_table[n].m_state = EXIST;
m_size++;
return true;
}
int find(const K& key)
{
int n = hashFunc(key);
while (m_table[n].m_state != EMPTY)
{
if (m_table[n].m_state == EXIST && m_table[n].m_val.first == key)
{
return n;
}
n++;
if (n == capacity())
{
n = 0;
}
}
return -1;
}
bool erase(const K& key)
{
int ret = find(key);
if (ret < 0)
{
return false; // 不存在
}
else
{
m_table[ret].m_state = DELETE;
m_size--;
}
}
size_t size()
{
return m_size;
}
bool empty()
{
return m_size == 0;
}
// 交换两个表（容器）
void Swap(hashTable<K, V>& ht)
{
m_table.swap(ht.m_table);
size_t tmp;
tmp = m_size;
m_size = ht.m_size;
ht.m_size = tmp;
}
};
// 素数表（除留余数法，最好模一个素数）
template<class K, class V, class SW>
long long hashTable<K, V, SW>::s_m_primeTable[30] = {
11, 23, 47, 89, 179,
353, 709, 1409, 2819, 5639,
11273, 22531, 45061, 90121, 180233,
360457, 720899, 1441807, 2883593, 5767169,
11534351, 23068673, 46137359, 92274737, 184549429,
369098771, 738197549, 1476395029, 2952790016u, 4294967291u
};
};
线性探测优点: 实现非常简单，
线性探测缺点: 一旦发生哈希冲突，所有的冲突连在一起，容易产生数据“堆积”，即:不同关键码占据 了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降低。 如何缓解呢?
- 二次探测
线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就 是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为:Hi = (H0 + i2)% m, 或者: Hi= ( H0 - i2 )% m。其中:i = 1,2,3…， 是通过散列函数Hash(x)对元素的关键码 key 进行 计算得到的位置，m是表的大小。
研究表明:当表的长度为质数且表装载因子a不超过0.5时，新的表项一定能够插入，而且任何一个位置都不会被探查两次。因此只要表中有一半的空位置，就不会存在表满的问题。在搜索时可以不考虑表装 满的情况，但在插入时必须确保表的装载因子a不超过0.5，如果超出必须考虑增容。
因此:闭散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。
开散列
开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。
从上图可以看出，开散列中每个桶中放的都是发生哈希冲突的元素
开散列增容
桶的个数是一定的，随着元素的不断插入，每个桶中元素的个数不断增多，极端情况下，可能会导致一个桶中链表节点非常多，会影响的哈希表的性能，因此在一定条件下需要对哈希表进行增容，那该条件怎么确认呢?开散列最好的情况是:每个哈希桶中刚好挂一个节点，再继续插入元素时，每一次都会发生哈希冲突，因此，在元素个数刚好等于桶的个数时，可以给哈希表增容。
开散列的实现
#pragma once
#include <vector>
using namespace std;
template<class T>
class HashBucketNode
{
T m_val;
HashBucketNode<T>* m_next;
HashBucketNode(const T& val = T()) :
m_val(val),
m_next(nullptr)
{}
template<class T, class SW>
friend class HashSet;
};
class dealInt
{
public:
int operator()(int n)
{
return n;
}
};
template<class T, class SW = dealInt>
class HashSet
{
vector<HashBucketNode<T>*> m_data;
size_t m_size;
static long long s_m_primeTable[30];
int m_primePos;
public:
HashSet(size_t capacity = s_m_primeTable[0]) :
m_data(capacity, nullptr),
m_size(0),
m_primePos(0)
{}
private:
int hashFunc(const T& key)
{
SW func;
return func(key) % capacity();
}
void checkCapacity()
{
if (m_size == capacity())
{
int mcapa = capacity();
vector<HashBucketNode<T>*> tmp(s_m_primeTable[++m_primePos], nullptr);
m_data.swap(tmp);
m_size = 0;
int i;
HashBucketNode<T>* cur;
for (i = 0; i < mcapa; i++)
{
for (cur = tmp[i]; cur; cur = cur->m_next)
{
insert(cur->m_val);
}
}
}
}
public:
bool insert(const T& val)
{
checkCapacity();
int hashnum = hashFunc(val);
HashBucketNode<T>* tmp;
if (m_data[hashnum])
{
for (tmp = m_data[hashnum]; tmp; tmp = tmp->m_next)
{
if (tmp->m_val == val)
{
return false;
}
}
}
tmp = new HashBucketNode<T>(val);
tmp->m_next = m_data[hashnum];
m_data[hashnum] = tmp;
m_size++;
return true;
}
bool erase(const T& val)
{
int hashnum = hashFunc(val);
HashBucketNode<T>* tmp;
if (!m_data[hashnum])
{
return false;
}
if (m_data[hashnum]->m_val == val)
{
tmp = m_data[hashnum];
m_data[hashnum] = tmp->m_next;
delete tmp;
m_size--;
return true;
}
else
{
for (tmp = m_data[hashnum]; tmp->m_next; tmp = tmp->m_next)
{
if (tmp->m_next->m_val == val)
{
HashBucketNode<T>* cur;
cur = tmp->m_next;
tmp->m_next = cur->m_next;
delete cur;
m_size--;
return true;
}
}
return false;
}
}
HashBucketNode<T>* find(const T& val)
{
int hashnum = hashFunc(val);
HashBucketNode<T>* cur;
for (cur = m_data[hashnum]; cur; cur = cur->m_next)
{
if (cur->m_val == val)
{
return cur;
}
}
return nullptr;
}
void clear()
{
HashBucketNode<T>* tmp;
for (auto& head : m_data)
{
while (head)
{
tmp = head;
head = head->m_next;
delete tmp;
}
}
m_size = 0;
}
size_t capacity()
{
return s_m_primeTable[m_primePos];
}
};
template<class T, class SW>
long long HashSet<T, SW>::s_m_primeTable[30] = {
11, 23, 47, 89, 179,
353, 709, 1409, 2819, 5639,
11273, 22531, 45061, 90121, 180233,
360457, 720899, 1441807, 2883593, 5767169,
11534351, 23068673, 46137359, 92274737, 184549429,
369098771, 738197549, 1476395029, 2952790016u, 4294967291u
};
开散列与闭散列比较
应用链地址法处理溢出，需要增设链接指针，似乎增加了存储开销。事实上: 由于开地址法必须保持大 量的空闲空间以确保搜索效率，如二次探查法要求装载因子a <= 0.5，而表项所占空间又比指针大的多，所以使用链地址法反而比开地址法节省存储空间。
unordered_map模拟实现（应用开散列）
main函数文件
#include "unordered_map.h"
#include <iostream>
using namespace std;
int main()
{
dg::unordered_map<int, int> hb;
hb[2] = 7;
hb[4] = 6;
hb[11] = 14;
hb[7] = 9;
hb[5] = 1;
for (auto& e : hb)
{
cout << e.first << ' ' << e.second << endl;
}
return 0;
}
unordered_map头文件
#include "HashBucket.h"
namespace dg {
template <class K, class V, class HF = dealInt>
class unordered_map
{
class KeyofValue
{
public:
const K& operator()(const pair<K, V>& data)
{
return data.first;
}
};
HashBucket<K, pair<K, V>, KeyofValue, HF> m_hb;
public:
// typename 是为了识别类型
typename typedef HashBucket<K, pair<K, V>, KeyofValue, HF>::iterator iterator;
unordered_map() :
m_hb()
{}
~unordered_map()
{
m_hb.~HashBucket();
}
iterator begin()
{
return m_hb.begin();
}
iterator end()
{
return m_hb.end();
}
iterator size()
{
return m_hb.size();
}
iterator find(const V& val)
{
return m_hb.find(val);
}
size_t count(const K& key)
{
return m_hb.count(key);
}
void clear()
{
return m_hb.clear();
}
bool empty()
{
return m_hb.empty();
}
pair<iterator, bool> insert(const pair<K, V> val)
{
return m_hb.insert(val);
}
V& operator[](const K& key)
{
pair<iterator, bool> ptmp = m_hb.insert(pair<K, V>(key, V()));
iterator itmp = ptmp.first;
return (*itmp).second;
}
const V& operator[](const K& key) const
{
return (*(m_hb.insert(pair<K, V>(key, V()))).first).second;
}
};
};
哈希桶头文件
#pragma once
#include <vector>
using namespace std;
namespace dg {
template<class T>
class HashBucketNode
{
T m_val;
HashBucketNode<T>* m_next;
HashBucketNode(const T& val = T()) :
m_val(val),
m_next(nullptr)
{}
template<class K, class V, class KeyofValue, class HF>
friend class HashBucket;
};
class dealInt
{
public:
int operator()(int n)
{
return n;
}
};
template<class K, class V, class KeyofValue, class HF = dealInt>
class HashBucket
{
vector<HashBucketNode<V>*> m_data;
size_t m_size;
static long long s_m_primeTable[30];
int m_primePos;
public:
HashBucket(size_t capacity = s_m_primeTable[0]) :
m_data(capacity, nullptr),
m_size(0),
m_primePos(0)
{}
~HashBucket()
{
clear();
}
class iterator
{
public:
HashBucket<K, V, KeyofValue, HF>* m_hb;
HashBucketNode<V>* m_node;
iterator(HashBucketNode<V>* node = nullptr,
HashBucket<K, V, KeyofValue, HF>* hbpos = nullptr) :
m_node(node),
m_hb(hbpos)
{}
iterator(const iterator& it) :
m_node(it.m_node),
m_hb(it.m_hb)
{}
V& operator*()
{
return m_node->m_val;
}
V* operator->()
{
return &m_node->m_val;
}
// 前置++
iterator operator++()
{
V val = m_node->m_val;
m_node = m_node->m_next;
if (!m_node)
{
int bucketno = m_hb->hashFunc(KeyofValue()(val)) + 1;
for (; bucketno < m_hb->capacity(); bucketno++)
{
if (m_hb->m_data[bucketno])
{
m_node = m_hb->m_data[bucketno];
break;
}
}
}
return *this;
}
iterator operator++(int)
{
HashBucket<K, V, KeyofValue, HF> tmp = *this;
++(*this);
return tmp;
}
bool operator==(const iterator& data) const
{
return m_node == data.m_node && m_hb == data.m_hb;
}
bool operator!=(const iterator& data) const
{
return m_node != data.m_node || m_hb != data.m_hb;
}
};
private:
int hashFunc(const K& key)
{
HF func;
return func(key) % capacity();
}
void checkCapacity()
{
if (m_size == capacity())
{
int mcapa = capacity();
vector<HashBucketNode<V>*> tmp(s_m_primeTable[++m_primePos], nullptr);
m_data.swap(tmp);
m_size = 0;
int i;
HashBucketNode<V>* cur;
for (i = 0; i < mcapa; i++)
{
for (cur = tmp[i]; cur; cur = cur->m_next)
{
insert(cur->m_val);
}
}
}
}
public:
iterator begin()
{
int bucketno = 0;
for (; bucketno < capacity(); bucketno++)
{
if (m_data[bucketno])
{
return iterator(m_data[bucketno], this);
}
}
return iterator(nullptr, this);
}
iterator end()
{
return iterator(nullptr, this);
}
pair<iterator, bool> insert(const V& val)
{
checkCapacity();
int hashnum = hashFunc(KeyofValue()(val));
HashBucketNode<V>* tmp;
if (m_data[hashnum])
{
for (tmp = m_data[hashnum]; tmp; tmp = tmp->m_next)
{
if (tmp->m_val == val)
{
pair<iterator, bool> pairtmp;
pairtmp.first = end();
pairtmp.second = false;
return pairtmp;
}
}
}
tmp = new HashBucketNode<V>(val);
tmp->m_next = m_data[hashnum];
m_data[hashnum] = tmp;
m_size++;
pair<iterator, bool> pairtmp;
iterator it(m_data[hashnum], this);
pairtmp.first = it;
pairtmp.second = true;
return pairtmp;
}
iterator erase(const V& val)
{
int hashnum = hashFunc(KeyofValue()(val));
HashBucketNode<V>* tmp;
if (!m_data[hashnum])
{
return end();
}
if (m_data[hashnum]->m_val == val)
{
iterator res(m_data[hashnum], this);
++res;
tmp = m_data[hashnum];
m_data[hashnum] = tmp->m_next;
delete tmp;
m_size--;
return res;
}
else
{
for (tmp = m_data[hashnum]; tmp->m_next; tmp = tmp->m_next)
{
if (tmp->m_next->m_val == val)
{
iterator res(tmp->m_next, this);
++res;
HashBucketNode<V>* cur;
cur = tmp->m_next;
tmp->m_next = cur->m_next;
delete cur;
m_size--;
return res;
}
}
return end();
}
}
iterator find(const V& val)
{
int hashnum = hashFunc(KeyofValue()(val));
HashBucketNode<V>* cur;
for (cur = m_data[hashnum]; cur; cur = cur->m_next)
{
if (cur->m_val == val)
{
return iterator(cur, this);
}
}
return iterator(nullptr, this);
}
void clear()
{
HashBucketNode<V>* tmp;
for (auto& head : m_data)
{
while (head)
{
tmp = head;
head = head->m_next;
delete tmp;
}
}
m_size = 0;
}
size_t capacity()
{
return s_m_primeTable[m_primePos];
}
size_t size()
{
return m_size;
}
bool empty()
{
return m_size == 0;
}
size_t count(const K& kv)
{
int bucketno = hashFunc(kv);
HashBucketNode<V>* cur;
for (cur = m_data[bucketno]; cur; cur = cur->m_next)
{
if (KeyofValue()(cur->m_val) == kv)
{
return 1;
}
}
return 0;
}
size_t bucketCount()
{
return capacity();
}
size_t bucketSize(size_t bucketno)
{
HashBucketNode<V>* cur;
int count = 0;
for (cur = m_data[bucketno]; cur; cur = cur->next)
{
count++;
}
return count;
}
};
template<class K, class V, class KeyofValue, class HF>
long long HashBucket<K, V, KeyofValue, HF>::s_m_primeTable[30] = {
11, 23, 47, 89, 179,
353, 709, 1409, 2819, 5639,
11273, 22531, 45061, 90121, 180233,
360457, 720899, 1441807, 2883593, 5767169,
11534351, 23068673, 46137359, 92274737, 184549429,
369098771, 738197549, 1476395029, 2952790016u, 4294967291u
};
};
代码生成图
知识点习题：
- 下面哪个说法是错误的
A. 哈希表不可以用数组实现
B. 队列可以用数组实现
C. 二叉树可以用数组来实现
D. 栈可以用单项链表来实现
正确答案： A
- hash map 线程不安全的原因，错误的是
A. jbk1.7中，在多线程环境下，扩容时会造成数据丢失
B. jbk1.7中，在多线程环境下，扩容时会造成环形链
C. jbk1.8中，在多线程环境下，扩容时会造成环形链
D. jbk1.8中，在多线程环境下，会发生数据覆盖的情况
正确答案： C
答案解析：
HashMap的线程不安全体现在会造成死循环、数据丢失、数据覆盖这些问题。其中死循环和数据丢失是在JDK1.7中出现的问题，在JDK1.8中已经得到解决，然而1.8中仍会有数据覆盖这样的问题。（Java 方面）
如有不同见解，欢迎留言讨论
扫一扫
1021
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
