哈希概念
- 顺序搜索以及二叉树搜索树中,元素存储位置和元素各关键码之间没有对应的关系,因此在查找一个元素时,必须要经过关键码的多次比较。搜索的效率取决于搜索过程中元素的比较次数。
- 理想的搜索方法:可以不经过任何比较,一次直接从表中得到要搜索的元素。
如果构造一种存储结构,通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系,那么在查找时通过该函数可以很快找到该元素。
当向该结构中:
- 插入元素时:根据待插入元素的关键码,以此函数计算出该元素的存储位置并按此位置进行存放
- 搜索元素时:对元素的关键码进行同样的计算,把求得的函数值当做元素的存储位置,在结构中按此位置取元素比较,若关键
码相等,则搜索成功 - 该方式即为哈希(散列)方法,哈希方法中使用的转换函数称为哈希(散列)函数,构造出来的结构称为哈希表(Hash Table)(或者
称散列表)
哈希冲突
- 对于两个数据元素的关键字 和 (i != j),有 != ,但有:
HashFun(Ki) == HashFun(Kj) 即不同关键字通过相同哈希哈数计算出相同的哈希地址,该种现象称为哈希冲突或哈希碰撞。把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。
处理哈希冲突
处理哈希冲突两种常见的方法:闭散列和开散列
- 闭散列
也叫开放地址法,当发生哈希冲突时,如果哈希表未被装满,说明在哈希表中必然还有空位置,那么可以把key存放到表中“下一个” 空位中去 。寻找“下一个”空位有两种常见的方法:1.线性探测 2.二次探测(Hi+1 = Hi + 2*i +1);
1.线性探测的缺点:一旦发生哈希冲突,所有的冲突连在一起,容易产生数据“堆积”,即:不同关键码占据了可利用的空位置,使得寻找某关键码的位置需要许多次比较,导致搜索效率降低–解决办法(负载因子–用空间换时间)
开散列
开散列法又叫链地址法(开链法)。
开散列法:首先对关键码集合用散列函数计算散列地址,具有相同地址的关键码归于同一子集合,每一个子集合称为一个桶,各个桶中的元素通过一个单链表链接起来,各链表的头结点存储在哈希表中。开散列表与闭散列表对比
开散列表:运用单链表存储方式,不产生堆积现象,应用链地址法处理溢出,需要增设链接指针,似乎增加了存储开销。事实上: 由于开地址法必须保持大量的空闲空间以确保搜索效率,如二次探测法要求负载因子a <= 0.7,而表项所占空间又比指针大的多,所以使用链地址法比使用开地址法更加节省空间。
闭散列表:运用顺序表存储,存储效率较高,但容易产生堆积,查找不易实现,需要用到二次再查找。
下面为开散列表的代码实现:
HashTable.h
#ifndef __HASHTABLE_H__
#define __HASHTABLE_H__
#include <stdio.h>
#include <assert.h>
#include <malloc.h>
//哈希表中每个位置的状态
typedef enum Stat
{
EM, //空
EX, //存在
DE //被删除
}Stat;
typedef int DataType;
typedef size_t(*PDTInt)(DataType str);
typedef enum
{
_IsLine, //线性探测
_IsNotLine //二次探测
}IsLine;
//哈希表每个位置包含数据和这个位置的状态
typedef struct Elem
{
DataType _data;
Stat stat;
}Elem;
typedef struct HashTable
{
Elem* _table;
int _capacity; //容量
int _size; //有效元素个数
int _total; //有效元素和被删除的元素之和
IsLine DetecWay; //发生哈希冲突的探测方法
PDTInt pDTInt; //将数据转化为整型,函数指针
}HTable;
//处理哈希冲突的方法--线性探测
int IsLineDetec(HTable* ht, int addr);
//二次探测
int NotIsLineDetec(HTable* ht, int addr, int i);
//初始化
void HashTableInit(HTable* ht, int capacity, IsLine DetecWay, PDTInt pDtInt);
//插入元素
void HashTableInsert(HTable* ht, DataType data);
//查找元素,找到返回地址
int HashTableFind(HTable* ht, DataType data);
//删除元素
void HashTableDelete(HTable* ht, DataType data);
int HashTableSize(HTable* ht);
int HashTableEmpty(HTable* ht);
//销毁哈希表
void HashTableDestory(HTable* ht);
#endif
HashTable.c
include “HashTable.h”
include “comm.h”
//哈希函数
static int HashFunc(HTable* ht, int data)
{
assert(ht);
return ht->pDTInt(data) % (ht->_capacity);
}
//处理哈希冲突的方法--线性探测
int IsLineDetec(HTable* ht, int addr)
{
addr = addr + 1;
if (addr == ht->_capacity)//如果越界
addr = 0;
return addr;
}
//二次探测
int NotIsLineDetec(HTable* ht, int addr, int i)
{
addr = addr + 2 * i + 1;
//如果越界不能直接置零,因为有可能i的值经过不断累加本身已经大于容量
if (addr >= ht->_capacity)
addr %= ht->_capacity;
return addr;
}
//初始化
void HashTableInit(HTable* ht, int capacity, IsLine DetecWay, PDTInt pDtInt)
{
int i = 0;
assert(ht);
//capacity = GetCapacity(capacity);
ht->_table = (Elem*)malloc(sizeof(Elem)*capacity);
if (NULL == ht->_table)
return;
for (; i < capacity; i++)
ht->_table[i].stat = EM;
ht->_capacity = capacity;
ht->_size = 0;
ht->_total = 0;
ht->DetecWay = DetecWay;
ht->pDTInt = pDtInt;
}
void _Swap(int* left, int* right)
{
assert(left);
assert(right);
int tmp = 0;
tmp = *left;
*left = *right;
*right = tmp;
}
void Swap(HTable* lht, HTable* rht)
{
assert(lht);
assert(rht);
_Swap(&(lht->_capacity), &(rht->_capacity));
_Swap(&(lht->_size), &(rht->_size));
_Swap((int*)&(lht->_table), (int*)&(rht->_table));
_Swap(&(lht->_total), &(rht->_total));
}
//检测容量
void CheckCapacity(HTable* ht)
{
assert(ht);
if ((ht->_total) * 10 / (ht->_capacity) >= 7)//负载因子
{
int i = 0;
//创建新哈希表
HTable NewHt;
//初始化新哈希表
HashTableInit(&NewHt, ht->_capacity*2, ht->DetecWay, ht->pDTInt);
//将原哈希表中的有效元素(EX)插到新哈希表的空间
for (; i < ht->_capacity; i++)
{
if (EX == ht->_table[i].stat)
HashTableInsert(&NewHt, ht->_table[i]._data);
}
//交换新旧哈希表
Swap(&NewHt, ht);
//销毁新哈希表
HashTableDestory(&NewHt);
}
}
//插入元素
void HashTableInsert(HTable* ht, DataType data)
{
int addr = 0;
int i = 0;
assert(ht);
//检查容量
CheckCapacity(ht);
addr = HashFunc(ht, data);
//如果计算出的地址不是空,就要一直找新地址
while (EM != ht->_table[addr].stat)
{
//设计的哈希表中的数据唯一
if (ht->_table[addr].stat == EX)
{
if (ht->_table[addr]._data == data)
return;
}
//计算出的地址不能使用,发生哈希冲突
if (ht->DetecWay == _IsLine)
addr = IsLineDetec(ht, addr);
else
addr = NotIsLineDetec(ht, addr, ++i);
}
//说明状态为空,可以直接插入
ht->_table[addr].stat = EX;
ht->_table[addr]._data = data;
ht->_size++;
ht->_total++;
}
//查找元素,找到返回地址
int HashTableFind(HTable* ht, DataType data)
{
int addr = 0;
int startaddr = 0;
int i = 0;
assert(ht);
addr = HashFunc(ht, data);
startaddr = addr;
//如果计算出的地址不是空,就要一直找新地址
while (EM != ht->_table[addr].stat)
{
//设计的哈希表中的数据唯一
if (ht->_table[addr].stat == EX)
{
if (ht->_table[addr]._data == data)
return addr;
}
//计算出的地址不能使用,发生哈希冲突
if (ht->DetecWay == _IsLine)
{
addr = IsLineDetec(ht, addr);
//如果转了一圈都没找到,就肯定没有
if (addr == startaddr)
return -1;
}
else
addr = NotIsLineDetec(ht, addr, ++i);
}
return -1;
}
//删除元素
void HashTableDelete(HTable* ht, DataType data)
{
int ret = 0;
assert(ht);
if (-1 == ret)
return;
ht->_table[ret].stat = DE;
ht->_size--;
}
int HashTableSize(HTable* ht)
{
return ht->_size;
}
int HashTableEmpty(HTable* ht)
{
return ht->_size == 0;
}
//销毁哈希表
void HashTableDestory(HTable* ht)
{
assert(ht);
free(ht->_table);
ht->_table = NULL;
ht->_capacity = 0;
ht->_size = 0;
ht->_total = 0;
}
comm.h
#pragma once
typedef unsigned long size_t;
typedef int DataType;
typedef size_t(*PDTInt)(DataType str);
//用来获取容量,使每次都是素数
int GetCapacity(int capacity);
size_t StrToInt(const char * str);
size_t IntToInt(int data);
comm.c
include “comm.h”
int GetCapacity(int capacity)
{
static const unsigned long _PrimeList[28] =
{
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
};
int i = 0;
for (; i < 28; i++)
{
if (capacity < _PrimeList[i])
return _PrimeList[i];
}
return _PrimeList[27];
}
//将字符串转换为整数
size_t StrToInt(const char * str)
{
unsigned int seed = 131; // 31 131 1313 13131 131313
unsigned int hash = 0;
while (*str)
{
hash = hash * seed + (*str++);
}
return (hash & 0x7FFFFFFF);
}
size_t IntToInt(int data)
{
return data;
}
test.c
include “comm.h”
include “HashTable.h”
void TestHashTable()
{
HTable ht;
HashTableInit(&ht, 5, _IsLine, IntToInt);//初始化
printf(“%d\n”, HashTableEmpty(&ht));
HashTableInsert(&ht, 20);//插入
HashTableInsert(&ht, 2);
HashTableInsert(&ht, 5);
HashTableInsert(&ht, 100);
HashTableInsert(&ht, 55);
HashTableInsert(&ht, 1);
HashTableInsert(&ht, 10);
printf(“size = %d\n”, HashTableSize(&ht));
printf("Find:%d\n", ht._table[HashTableFind(&ht, 20)]._data);//查找
HashTableDelete(&ht, 55);//删除
printf("size = %d\n", HashTableSize(&ht));
HashTableDestory(&ht);
}
int main()
{
TestHashTable();//动态闭散列哈希表
}