这篇博客的目的是让尚未学会hash表的朋友们对hash表有一个直观的理解，并且能根据本文定义出属于自己的第一个hash表，但算不上研究文，没有深究概念和成功案例。
什么是hash表？
hash表也叫做散列表，是一种通过键值快速访问数据的结构，hash表有两种常见的定义形式：数组、数组和链表的结合。
理解hash表的关键：
1.散列法
将字符组成的字符和字符串转换为固定长度的数值和索引值的方法，通过更短的hash值进行搜索比用原值搜索更快，通常用于数据库建立索引或者加解密。
2.装填因子
设m和n分别表示表长和表中填入的节点数，将α=n/m定义为散列表的装填因子，装填因子越大，越容易冲突。
3.散列函数
压缩待处理的键值，降低空间开销。
4.冲突
两个不同的键值具有同一个散列函数值，因而映射到散列表的同一位置，称为冲突或碰撞，冲突的两个键值称为同义词。
冲突与散列函数有关，也和表的装填因子有关，hash表在即将填满时冲突几率提高，性能下降严重，但整体是一种极其高效的算法。
hash表基本上无法避免冲突。
5.处理冲突
如果由键值得到的散列函数值（以后用hash地址称呼）已经存有记录，则继续寻找下一个空的hash地址。
常见的处理冲突方法有开放寻址法、再散列法、拉链法、建立公共溢出区。
以拉链法定义hash表为例：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<Windows.h>
using namespace std;
//用于避免冲突的链表，同义键值插入链表
//散列法中装填因子可以大于1，即待插入表元素总数可以大于表长度，但通常建议装填因子<=1，可以最大限度通过键值直接映射hash表
struct Node
{
int data;
struct Node* next;
};
//hash表主体，上面的链表是用来辅助解决冲突的
struct Hash_Table
{
Node* Value[100];
};
//创建hash表
Hash_Table* CreateHashTable()
{
Hash_Table* ptHash = (Hash_Table*)malloc(sizeof(Hash_Table));
memset(ptHash, 0, sizeof(Hash_Table));
return ptHash;
}
//在Hash表中寻找数据
//hash法为除留余数法
Node* FindHashData(Hash_Table* pHashTbl, int data)
{
Node* pNode;
if (NULL == pHashTbl)
return NULL;
if (NULL == (pNode = pHashTbl->Value[data % 100])) //该hash地址尚未插入数据,data%100就是此处应用的hash法
return NULL;
//遍历该hash地址指向的单链表的数据，如果键值等于hash表中存储的键值数据，匹配到就返回节点。
while (pNode)
{
if (data = pNode->data)
return pNode;
pNode = pNode->next;
}
return NULL;
}
//在Hash表中插入数据
BOOL InsertDataIntoHashTable(Hash_Table* pHashTbl, int data)
{
Node* pNode;
if (NULL == pHashTbl)
return NULL;
if (NULL == pHashTbl->Value[data % 100]) //该节点尚未插入数据
{
pNode = (Node*)malloc(sizeof(Node));
pNode->data = data;
pNode->next = NULL;
pHashTbl->Value[data % 100] = pNode;
return TRUE;
}
//如果该键值已经插入hash表则插入失败，hash表存在同义键值，但不保存重复键值的数据
if (NULL != FindHashData(pHashTbl, data))
return FALSE;
pNode = pHashTbl->Value[data % 100];
while (NULL != pNode)
pNode = pNode->next;
//插入hash地址指向链表的末尾
pNode->next = (Node*)malloc(sizeof(Node));
pNode->next->data = data;
pNode->next->next = NULL;
return TRUE;
}
//从hash表中删除数据
BOOL DeleteDataFromHashTable(Hash_Table* pHashTbl, int data)
{
Node* pNode,*pHead;
if (NULL == pHashTbl)
return FALSE;
if (NULL == pHashTbl->Value[data % 100])
return FALSE;
if (NULL == (pNode = FindHashData(pHashTbl, data)))
return FALSE;
//如果查找到的hash节点是hash地址链表的首元素，重定向指针并删除。
if (pNode == pHashTbl->Value[data % 100])
{
pHashTbl->Value[data % 100]->next = pNode->next;
free(pNode);
return TRUE;
}
//如果查找到的hash节点不是hash地址链表的首元素，定位到pNode的上一个节点后重定向指针并删除。
pHead = pHashTbl->Value[data % 100];
while (pHead->next != pNode)
pHead = pHead->next;
pHead->next = pNode->next;
free(pHead);
return TRUE;
}
上面的例子是读过一位前辈的例子后模仿的，前辈的例子已经非常精炼，很难有修改的地方，就加了一些注释方便大家理解，下面是学习开放定址法后自己写的一个例子，请大家指教。
//依据hash处理冲突的开放寻址法
//开放寻址法有三种探查技术：这里用的线性探测再散列方法
typedef enum _USE_STATUS {
STATUS_EMPTY = 0,
STATUS_NORMAL_USE = 1,
STATUS_DELETED = 2
}USE_STATUS;
struct HASH_DATA
{
int keyvalue;
USE_STATUS use;
};
struct HASH_TABLE
{
HASH_DATA data[100];
};
//定义哈希函数，又称散列函数
int hash_func(int key)
{
return key%10;
};
//定义处理冲突的增量序列,线性探测再散列方法增量
//线性探测的缺点：1.处理溢出需另编程序。2.删除工作困难，删除元素的时候需要将单元打上删除标记，不能直接设置元素为空，否则影响后续探测。
//3.处理不确定的关键字域时很容易产生堆聚现象，堆聚具有一旦堆聚就更加容易堆聚的特点。
int hash_di(int val)
{
return val;
};
HASH_TABLE* CreateHashTable()
{
HASH_TABLE* hash = new HASH_TABLE;
memset(hash, 0, sizeof(HASH_TABLE));
return hash;
};
//若是当前探查的单元为空，表示查找失败
//若探查到T[d-1]仍然没有查找到，表示查找失败
HASH_DATA* FindHashTable(HASH_TABLE* head, int key)
{
for(int i = 0; i < 100; i++)
{
if(head->data[(hash_func(key)+hash_di(i))%100].keyvalue == key && STATUS_NORMAL_USE == head->data[(hash_func(key)+hash_di(i))%100].use)
{
return &(head->data[hash_func(key)+i]);
}
if(STATUS_EMPTY == head->data[(hash_func(key)+hash_di(i))%100].use)
return NULL;
}
return NULL;
}
//若是当前探查的单元中含有key，则插入失败
//找到空元素或者已删除的元素就插入其中
BOOL InsertHashNode(HASH_TABLE* head, int key)
{
for(int i = 0; i < 100; i++)
{
if(head->data[(hash_func(key)+hash_di(i))%100].use == STATUS_DELETED || head->data[(hash_func(key)+hash_di(i))%100].use == STATUS_EMPTY)
{
head->data[(hash_func(key)+hash_di(i))%100].keyvalue = key;
head->data[(hash_func(key)+hash_di(i))%100].use = STATUS_NORMAL_USE;
return TRUE;
}
}
return FALSE;
}
//若是探查T[d-1]的时候仍然未找到包含key的单元，则删除失败
//线性探查法找到待删除的元素时只能标记为已删除
//当找到为空的元素仍然没有找到对应的key，则删除失败
BOOL DeleteHashNode(HASH_TABLE* head, int key)
{
for(int i = 0; i < 100; i++)
{
if(head->data[(hash_func(key)+hash_di(i))%100].keyvalue == key && STATUS_NORMAL_USE == head->data[(hash_func(key)+hash_di(i))%100].use)
{
head->data[(hash_func(key)+hash_di(i))%100].use = STATUS_DELETED;
return TRUE;
}
else if(STATUS_EMPTY == head->data[(hash_func(key)+hash_di(i))%100].use)
{
return FALSE;
}
}
return FALSE;
}
