哈希表

哈希表

散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。

1

给定一个表用来存放数据，对于给定的关键字可以通过哈希函数计算出相应的值找到该关键字在表中的位置。

不同的关键字可能得到同一散列地址，即k1≠k2，而f(k1)=f(k2)，这种现象称为冲突（英语：Collision）。具有相同函数值的关键字对该散列函数来说称做同义词。综上所述，根据散列函数f(k)和处理冲突的方法将一组关键字映射到一个有限的连续的地址集（区间）上，并以关键字在地址集中的“像”作为记录在表中的存储位置，这种表便称为散列表，这一映射过程称为散列造表或散列，所得的存储位置称散列地址。

若对于关键字集合中的任一个关键字，经散列函数映象到地址集合中任何一个地址的概率是相等的，则称此类散列函数为均匀散列函数（Uniform Hash function），这就是使关键字经过散列函数得到一个“随机的地址”，从而减少冲突。

常用哈希函数方法

1 直接寻址法

取关键字或关键字的某个线性函数作为散列地址。如H(key)或H(a*key+b),通过函数得到相应的地址，若为空直接放入，若不为空，往后找直到为空为止。

2 数字分析法

数字分析法就是找出数字的规律，尽可能利用这些数据来构造冲突几率较低的散列地址。

如出生年月，前面的年分大多相同,易构成冲突，但后面的日期多不相同，所以采用后面日期作为寻址依据。

3. 平方取中法：

当无法确定关键字中哪几位分布较均匀时，可以先求出关键字的平方值，然后按需要取平方值的中间几位作为哈希地址。这是因为：平方后中间几位和关键字中每一位都相关，故不同关键字会以较高的概率产生不同的哈希地址。 [2]
例：我们把英文字母在字母表中的位置序号作为该英文字母的内部编码。例如K的内部编码为11，E的内部编码为05，Y的内部编码为25，A的内部编码为01, B的内部编码为02。由此组成关键字“KEYA”的内部代码为11052501，同理我们可以得到关键字“KYAB”、“AKEY”、“BKEY”的内部编码。之后对关键字进行平方运算后，取出第7到第9位作为该关键字哈希地址，如下图所示
关键字
内部编码
内部编码的平方值
“KYAB”、“AKEY”、“BKEY”的内部编码。之后对关键字进行平方运算后，取出第7到第9位作为该关键字哈希地址

4. 折叠法：

将关键字分割成位数相同的几部分，最后一部分位数可以不同，然后取这几部分的叠加和（去除进位）作为散列地址。数位叠加可以有移位叠加和间界叠加两种方法。移位叠加是将分割后的每一部分的最低位对齐，然后相加；间界叠加是从一端向另一端沿分割界来回折叠，然后对齐相加。

5 随机数法

取一个随机函数，给出随机数，通常用于关键字不同的场合。

6 除留余数法

取关键字被某个不大于表长好H（key）=key%m的数取余所得的余数为地址，如果不为空依次往后找直到为空为止。
m一般取表长或不大于表长的素数。m 的选取较为关键，若选取不好，容易造成冲突。

处理冲突的方法

1 开放寻址法

这种方法也称再散列法，其基本思想是：当关键字key的哈希地址p=H（key）出现冲突时，以p为基础，产生另一个哈希地址p1，如果p1仍然冲突，再以p为基础，产生另一个哈希地址p2，…，直到找出一个不冲突的哈希地址pi ，将相应元素存入其中。这种方法有一个通用的再散列函数形式：
Hi=（H（key）+di）% m i=1，2，…，n
其中H（key）为哈希函数，m 为表长，di称为增量序列。增量序列的取值方式不同，相应的再散列方式也不同。主要有以下三种：
l 线性探测再散列
dii=1，2，3，…，m-1
这种方法的特点是：冲突发生时，顺序查看表中下一单元，直到找出一个空单元或查遍全表。
l 二次探测再散列
di=12，-12，22，-22，…，k2，-k2 ( k<=m/2 )
这种方法的特点是：冲突发生时，在表的左右进行跳跃式探测，比较灵活。
l 伪随机探测再散列
di=伪随机数序列。
具体实现时，应建立一个伪随机数发生器，（如i=(i+p) % m），并给定一个随机数做起点。
例如，已知哈希表长度m=11，哈希函数为：H（key）= key % 11，则H（47）=3，H（26）=4，H（60）=5，假设下一个关键字为69，则H（69）=3，与47冲突。如果用线性探测再散列处理冲突，下一个哈希地址为H1=（3 + 1）% 11 = 4，仍然冲突，再找下一个哈希地址为H2=（3 + 2）% 11 = 5，还是冲突，继续找下一个哈希地址为H3=（3 + 3）% 11 = 6，此时不再冲突，将69填入5号单元，参图8.26 (a)。如果用二次探测再散列处理冲突，下一个哈希地址为H1=（3 + 12）% 11 = 4，仍然冲突，再找下一个哈希地址为H2=（3 - 12）% 11 = 2，此时不再冲突，将69填入2号单元，参图8.26 (b)。如果用伪随机探测再散列处理冲突，且伪随机数序列为：2，5，9，………，则下一个哈希地址为H1=（3 + 2）% 11 = 5，仍然冲突，再找下一个哈希地址为H2=（3 + 5）% 11 = 8，此时不再冲突，将69填入8号单元，
这种方法也称再散列法，其基本思想是：当关键字key的哈希地址p=H（key）出现冲突时，以p为基础，产生另一个哈希地址p1，如果p1仍然冲突，再以p为基础，产生另一个哈希地址p2，…，直到找出一个不冲突的哈希地址pi ，将相应元素存入其中。这种方法有一个通用的再散列函数形式：
Hi=（H（key）+di）% m i=1，2，…，n
其中H（key）为哈希函数，m 为表长，di称为增量序列。增量序列的取值方式不同，相应的再散列方式也不同。主要有以下三种：
l 线性探测再散列
dii=1，2，3，…，m-1
这种方法的特点是：冲突发生时，顺序查看表中下一单元，直到找出一个空单元或查遍全表。
l 二次探测再散列
di=12，-12，22，-22，…，k2，-k2 ( k<=m/2 )
这种方法的特点是：冲突发生时，在表的左右进行跳跃式探测，比较灵活。
l 伪随机探测再散列
di=伪随机数序列。
具体实现时，应建立一个伪随机数发生器，（如i=(i+p) % m），并给定一个随机数做起点。
例如，已知哈希表长度m=11，哈希函数为：H（key）= key % 11，则H（47）=3，H（26）=4，H（60）=5，假设下一个关键字为69，则H（69）=3，与47冲突。如果用线性探测再散列处理冲突，下一个哈希地址为H1=（3 + 1）% 11 = 4，仍然冲突，再找下一个哈希地址为H2=（3 + 2）% 11 = 5，还是冲突，继续找下一个哈希地址为H3=（3 + 3）% 11 = 6，此时不再冲突，将69填入5号单元，参图8.26 (a)。如果用二次探测再散列处理冲突，下一个哈希地址为H1=（3 + 12）% 11 = 4，仍然冲突，再找下一个哈希地址为H2=（3 - 12）% 11 = 2，此时不再冲突，将69填入2号单元，参图8.26 (b)。如果用伪随机探测再散列处理冲突，且伪随机数序列为：2，5，9，………，则下一个哈希地址为H1=（3 + 2）% 11 = 5，仍然冲突，再找下一个哈希地址为H2=（3 + 5）% 11 = 8，此时不再冲突，将69填入8号单元.

3 再哈希法

构造多个不同的哈希函数，在发生冲突时采用不同的哈希函数，直到不再冲突为止。增加了计算时间。

4 链地址法

当发生冲突时采用链式结构，将相同地址的数链接在后面。适用于经常删除和增加的情况。

当同一地址连接的数据过多时，就会造成效率过低，退化。

5 建立公共溢出区

将哈希表分为基本数据表和溢出表。
当发生冲突时，将冲突数据填入溢出表。

影响产生冲突多少有以下三个因素：

1. 散列函数是否均匀；
2. 处理冲突的方法；
3. 散列表的装填因子。
   散列表的装填因子定义为：α= 填入表中的元素个数 / 散列表的长度
   α是散列表装满程度的标志因子。由于表长是定值，α与“填入表中的元素个数”成正比，所以，α越大，填入表中的元素较多，产生冲突的可能性就越大；α越小，填入表中的元素较少，产生冲突的可能性就越小。
   实际上，散列表的平均查找长度是装填因子α的函数，只是不同处理冲突的方法有不同的函数。

平均查找长度

哈希表接口

typedef int HTKeyType;
typedef int HTValueType;
typedef int size_t;
//状态结构体，表中节点的状态
typedef enum State
{
	EMPTY,
	EXIITS,
	DELETE,
}State;
//节点结构体
typedef struct HashData
{
	State		_state;
	HTKeyType	_key;
	HTValueType _value;
}HashData;
//表结构体
typedef struct HashTable
{
	HashData* _tables;  //表
	size_t _len;   // 长度
	size_t _size;  // 有效数据个数
}HashTable;

哈希表的初始化

//hash表的初始化
void HTInit(HashTable* ht, size_t len)
{
	assert(ht);
	int i;
	if ((ht->_tables = (HashData*)malloc(sizeof(HashData)*len)) == NULL)
		return;
	ht->_len = len;
	ht->_size = 0;
	for (i = 0; i <ht->_len; i++)
	{
		ht->_tables[i]._state = EMPTY;   //将表的所有节点状态置为空
	}
}

数据插入

int HTInsert(HashTable* ht, HTKeyType key, HTValueType value)
{
	assert(ht);
	int index;
	ht=CheckCapacity(ht, value);
	index = HashFunc(ht,key);    //计算数据地址
	while (ht->_tables[index]._state == EXIITS)      //当节点状态为空或delete时即可进行插入
	{
		if (ht->_tables[index]._key == key&&index<ht->_len)
			return 0;
		else {
			index++;                           //当已有数据时找下一个
			if (index >= ht->_len)
				index -= ht->_len;   
		}
	}
	ht->_tables[index]._key = key;
	ht->_tables[index]._state = EXIITS;
	ht->_size++;
}


void HTDestroy(HashTable* ht)     
{
	assert(ht);
	free(ht->_tables);
	ht->_tables = NULL;
	ht->_len = ht->_size = 0;
}
int HashFunc(HashTable* ht, HTKeyType key)
{
	assert(ht);
	int index;
	if (ht->_len > 0)
	{
		return key%ht->_len;
	}
	else
		return 0;
}

HashTable* CheckCapacity(HashTable* ht, HTKeyType key)   //扩容
{
	assert(ht);
	int i;
	if (ht->_size * 10 / ht->_len > 7)      //当该表的散列因子过大时，进行表的增容
	{
		HashTable new;
		HashTable* newht=&new;              //构建一个新的二倍容量的哈希表
		HTInit(newht, ht->_len * 2);

		for (i = 0; i < ht->_len; i++)
		{
			if (ht->_tables[i]._state != EMPTY)
			{
				HTInsert(newht, ht->_tables[i]._key, ht->_tables[i]._value);   //将原表数据重新插入新表，此时数据的地址会发生变化
				newht->_size++;
			}
				
		}
		HTInit(ht, ht->_len * 2);
		memcpy(ht->_tables,newht->_tables,sizeof(HashData)*newht->_len);      //将新表数据拷贝到原表，相当于完成增容
		ht->_len = newht->_len;
		ht->_size - newht->_size;
		HTDestroy(newht);

	}
	return ht;
}

哈希表的删除和查找

int HTRemove(HashTable* ht, HTKeyType key)     //删除表中数据，只改变其状态和和表中数据的大小
{
	assert(ht);
	HashData* node;
	if (HTEmpty(ht) == 1)
		return 0;
	node=HTFind(ht, key);
	if (node != NULL)
	{
		node->_state = DELETE;
		ht->_size--;
		return 1;
	}
	else
		return 0;
}
HashData* HTFind(HashTable* ht, HTKeyType key)       //查找数据
{
	assert(ht);
	int index;
	index = HashFunc(ht,key);
	while (ht->_tables[index]._state != EMPTY)
	{

		if (ht->_tables[index]._key == key)
		{
			if (ht->_tables[index]._state == DELETE)
				return NULL;
			return &ht->_tables[index];
		}
		else
			index++;
	}
	return NULL;

}