一、哈希概念
引入：
顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应关系，因此在查找一个元素时，必须要经过关键码的多次比较。其中顺序查找的时间复杂度为O(N)，平衡树中为树的高度，即O()，搜索的效率取决于搜索过程中元素的比较次数。
理想的搜索方法：
可以不经过任何比较，直接从表中得到要搜索的元素。如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射关系，那么在查找时通过该函数可以很快的找到该元素。
插入元素：
根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放。
搜索元素：
对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素进行比较，若关键码相等，则搜索成功。
哈希（散列）方法：
以上方式即为哈希方法，哈希方法中使用的转换函数称为哈希（散列）函数，构造出来的结构称为哈希表（Hash Table），或称为散列表。
二、哈希冲突（哈希碰撞）
1.概念
不同的关键字通过相同的哈希函数计算出了相同的哈希地址，这种现象就称为哈希冲突或哈希碰撞。
2.哈希函数
引起哈希冲突的一个原因可能是哈希函数设计不合理。
2.1哈希函数设计原则
（1）哈希函数的定义域必须包括需要存储的全部关键字，如果散列表允许有m个地址时，其值域必须在0到m-1之间；
（2）函数函数计算出的哈希地址能够均匀分布在整个空间内；
（3）哈希函数设计应该尽可能简单。
2.2常见哈希函数
（1）直接定制法（常用）
取关键字的某个线性函数为散列地址：Hash(key) =A*key+B。
优点：简单、均匀；
缺点：需要事先知道关键字的分布情况。
使用场景：适合查找数据量比较小，且连续的情况。
（2）除留余数法（常用）
假设散列表中允许的地址数为m，取一个不大于m，但接近或等于m的质数p作为除数，按照哈希函数：Hash(key)=key%p(p<=m)，将关键码转换成哈希地址。
（3）平方取中法
假设关键字为1234，对它进行平方为1522756，抽取中间三位227作为哈希地址。平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况。
（4）折叠法
折叠法是将关键字从左到右分割成位数相等的几部分（最后一部分位数可以不足），然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。
折叠法适合事先不需要知道关键字分布，和关键字位数比较多的情况。
（5）随机数法
选择一个随机函数，取关键字的随机函数值作为哈希地址：Hash(key)=random(key)，其中random为随机数函数。
随机数法通常用于关键字长度不等的情况。
（6）数学分析法
假设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有几种符号经常出现。就可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。
数学分析法通常适合出来关键字位数比较大的情况，且事先知道关键字的分布且关键字的若干位分布较均匀的情况。
注意：哈希函数设计的越精妙，产生哈希冲突的机率就越低，但是无法完全避免。
三、哈希冲突解决方法
1. 闭散列（开放地址法）
闭散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。
闭散列：也叫开放地址法，当发生哈希冲突时，如果哈希表未被装满，那么可以把key存放到冲突位置的“下一个"空位置中去。那么如何查找下一个空位置？
1.1 线性探测
原理：
从发生冲突的位置开始，依次向后探测，直到找到下一个空位置为止。
插入：
通过哈希函数获取待插入元素在哈希表中的位置，如果该位置中没有元素则直接插入元素；如果该位置中已有元素发生哈希冲突，则使用线性探测找到下一个空位置，再插入元素。
删除：
采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响到其他元素的搜索。比如两个关键字的哈希地址相同，一个通过线性探测插入到了后面的空位置，若直接删除前面的关键字，则会影响到后面关键字的搜索。
因此线性探测采用标记的伪删除方式，来删除一个元素。
优点：实现简单
缺点：一旦发生哈希冲突，冲突的元素连在一起，容易产生数据堆积，即：不同的关键码占据了可利用的空位置，使得寻找某关键码的位置需要多次比较，导致搜索效率降低。
负载因子（载荷因子）=有效元素个数/表格容量
线性探测法的负载因子：一般控制在0.7左右。
1.2 二次探测
原理：
线性探测的缺陷是产生冲突的数据容易堆积在一起，这与其查找下一个空位置的方式为往后逐个探测有关系，因此二次探测为了避免该问题，找下一个空位置的方法为：，或者：，其中i=1，2，3……，是通过哈希函数对元素的关键码key进行计算得到的位置，m是哈希表的大小。
注意：
研究表明：当表的长度为质数且负载因子不超过0.5时，新的表项一定能够插入，且任何一个位置都不会被探测两次，因此只要表项中有一半的空位置，就不会存在表满的问题。
所以二次探测法，在搜索时可以不考虑表装满的情况，但是在插入时必须确保负载因子不超过0.5，超出则需要考虑扩容。
2.开散列（链地址法）
2.1 开散列概念
开散列法又叫链地址法（开链法），其思想是：首先对关键码集合用哈希函数计算哈希地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。
2.2 开散列的实现
HashBucket.hpp:
#pragma once
#include
#include "Common.h"
//桶内链表节点
template
struct HashBucketNode {
HashBucketNode
T _value;
HashBucketNode(const T& value = T())
: _next(nullptr)
, _value(value)
{}
};
template
class HashBucket {
typedef HashBucketNode
public:
HashBucket(size_t initCapacity = 10)
: _table(GetNextPrime(initCapacity))
, _size(0)
{}
//插入元素
//1.不能存放重复元素
bool InsertUnique(const T& value) {
CheckCapacity();
//①计算哈希地址--桶号
size_t bucket = HashFunction(value);
//②在bucket对应的桶内查找是否已经存在元素value
Node* cur = _table[bucket];
while (cur) {
if (cur->_value == value) {
return false;
}
cur = cur->_next;
}
//③插入新节点
cur = new Node(value);
cur->_next = _table[bucket];
_table[bucket] = cur;
++_size;
return true;
}
//2.可以存放重复元素
bool InsertEqual(const T& value) {
CheckCapacity();
//①计算哈希地址--桶号
size_t bucket = HashFunction(value);
//②插入新节点
Node* cur = new Node(value);
cur->_next = _table[bucket];
_table[bucket] = cur;
++_size;
return true;
}
//删除
//1.不能存放重复元素
bool EraseUnique(const T& value) {
//①计算哈希地址--桶号
size_t bucket = HashFunction(value);
//②在bucket对应的桶内查找元素value
Node* cur = _table[bucket];
Node* prev = nullptr;
while (cur) {
if (cur->_value == value) {
if (nullptr == prev) {//元素为链表的第一个节点
_table[bucket] = cur->_next;
delete cur;
}
else {
prev->_next = cur->_next;
delete cur;
}
--_size;
return true;
}
else {
prev = cur;
cur = cur->_next;
}
}
return false;
}
//2.可以存放重复元素
bool EraseEqual(const T& value) {
size_t oldSize = _size;
//①计算哈希地址--桶号
size_t bucket = HashFunction(value);
//②在bucket对应的桶内查找元素value
Node* cur = _table[bucket];
Node* prev = nullptr;
while (cur) {
if (cur->_value == value) {
if (nullptr == prev) {//元素为链表的第一个节点
_table[bucket] = cur->_next;
delete cur;
cur = _table[bucket];
}
else {
prev->_next = cur->_next;
delete cur;
cur = prev->_next;
}
--_size;
}
else {
prev = cur;
cur = cur->_next;
}
}
return oldSize != _size;
}
//查找
Node* Find(const T& value) {
//①计算哈希地址--桶号
size_t bucket = HashFunction(value);
//②在bucket对应的桶内查找元素value
Node* cur = _table[bucket];
while (cur) {
if (cur->_value == value) {
return cur;
}
cur = cur->_next;
}
return nullptr;
}
//容量
size_t Size() const {
return _size;
}
//测试函数：打印每个桶内元素
void PrintBucket() {
for (size_t i = 0; i < _table.capacity(); ++i) {
std::cout << "table[" << i << "]: ";
Node* cur = _table[i];
while (cur) {
std::cout << cur->_value << "-->";
cur = cur->_next;
}
std::cout << "NULL" << std::endl;
}
}
private:
size_t HashFunction(const T& value) {//哈希函数
T2INT t2int;
return t2int(value) % _table.capacity();
}
size_t HashFunction(const T& value, size_t capacity) {//哈希函数
T2INT t2int;
return t2int(value) % capacity;
}
void CheckCapacity() {//检测扩容
if (_size == _table.capacity()) {
//1.申请新空间
std::vector
//2.拷贝元素：将每个桶内的元素搬移到新桶中
for (size_t i = 0; i < _table.capacity(); ++i) {
Node* cur = _table[i];
while (cur) {
//将节点从链表上拆下来
_table[i] = cur->_next;
//散列到新桶中
size_t newBucket = HashFunction(cur->_value, newTable.capacity());
cur->_next = newTable[newBucket];
newTable[newBucket] = cur;
//取旧桶内的下一个节点
cur = _table[i];
}
}
//3.
_table.swap(newTable);
}
}
private:
std::vector
size_t _size;//有效元素个数
};
Common.h：
#pragma once
//将类型转换为整形
#include
template
class T2INT {//int
public:
size_t operator()(const T& data) {
return data;
}
};
class Str2INT {//string
public:
size_t operator()(const std::string& str) {
return SDBMHash(str.c_str());
}
unsigned int SDBMHash(const char* str) {
unsigned int hash = 0;
unsigned int seed = 131;
while (*str) {
hash = hash * seed + (*str++);
}
return (hash & 0x7FFFFFFF);
}
};
//增容质数表
const int PRIMECOUNT = 31;
const size_t primeList[PRIMECOUNT] =
{
5,11, 23,
53ul, 97ul, 193ul, 389ul, 769ul,
1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
1610612741ul, 3221225473ul, 4294967291ul
};
size_t GetNextPrime(size_t prime) {
for (size_t i = 0; i < PRIMECOUNT; ++i) {
if (primeList[i] > prime) {
return primeList[i];
}
}
return primeList[PRIMECOUNT - 1];
}
相关阅读
发表评论