数据结构 学习笔记（完）：散列查找：散列（哈希）表，散列函数的构造，冲突处理，性能分析

11.1 散列表（哈希表）

11.1.1 散列的基本思路

散列查找。

先讲一个例子：

比如说，C 语言编译的时候，C语言里有个规则就是变量名必须先定义（或声明）后再使用。当编译器碰到变量名的时候，它可能在两个位置，一个是在它定义（或声明）的地方，一个是在它使用的地方。当编译器碰到他使用的地方，它就要检查，该变量是否定义过，如果没有定义过，就会报错；如果定义过，还要知道这个变量是什么类型的，这种类型在这个语句环境里是不是可以用。这就涉及到一个变量管理的问题。

抽象一下，编译处理时，就是对变量名以及变量属性的管理：

插入：新变量的定义

查找：变量的引用

还有可能有删除变量的操作

因此，编译处理中对变量的管理实际上是一个动态查找的问题。

在之前，我们讲过动态查找可以使用查找树（AVL），那么这个问题上，我们可以用AVL 查找树么？

在查找树中，我们经常要把关键词和当前结点的值进行比较。但针对变量管理时，意味着我们要将两个变量名（字符串）进行比较，而字符串的比较效率通常不高（因为要一个一个的字符比较下去）。

所以我们用 AVL 树不能很好的解决问题。这时候我们想：是否可以先把字符串转换为数字，再处理？（散列查找的一种思想）

查找的本质：已知对象找位置

有序安排对象：全序（二分查找）、半序（查找树）

直接“算出”对象位置：散列

散列查找法的两项基本工作：

计算位置：构造散列函数确定关键词存储位置

解决冲突：应用某种策略解决多个关键词位置相同的问题

时间复杂度几乎是常量：O（1），即查找时间与问题规模无关。

11.1.2 什么是散列表

散列的基本思想 是：



例子：

11.2 散列函数的构造方式

一个“好”的散列函数一般应考虑下列两个因素：

计算简单，以便提高转换速度

关键词对应的地址空间分布均匀，以尽量减少冲突

11.2.1 数字关键词的散列函数的构造

直接定址法

除留余数法

数字分析法

折叠法

平方取中法

11.2.2 字符串关键词的散列函数的构造

11.3 冲突处理方法

常用处理冲突的方法：

换个位置：开放地址法

同一位置的冲突对象组织在一起：链地址法

11.3.1 开放定址法

开放地址法思路：一旦产生了冲突（该地址已经有其他元素），就按某种规则去寻找另一空地址。



C 语言实现：创建开放定址法的散列表

#define MAXTABLESIZE 100000 /* 允许开辟的最大散列表长度 */
typedef int ElementType;    /* 关键词类型用整型 */
typedef int Index;          /* 散列地址类型 */
typedef Index Position;     /* 数据所在位置与散列地址是同一类型 */
/* 散列单元状态类型，分别对应：有合法元素、空单元、有已删除元素 */
typedef enum { Legitimate, Empty, Deleted } EntryType;

typedef struct HashEntry Cell; /* 散列表单元类型 */
struct HashEntry{
ElementType Data; /* 存放元素 */
EntryType Info;   /* 单元状态 */
};

typedef struct TblNode *HashTable; /* 散列表类型 */
struct TblNode {   /* 散列表结点定义 */
int TableSize; /* 表的最大长度 */
Cell *Cells;   /* 存放散列单元数据的数组 */
};

int NextPrime( int N )
{ /* 返回大于N且不超过MAXTABLESIZE的最小素数 */
int i, p = (N%2)? N+2 : N+1; /*从大于N的下一个奇数开始 */

while( p <= MAXTABLESIZE ) {
for( i=(int)sqrt(p); i>2; i-- )
if ( !(p%i) ) break; /* p不是素数 */
if ( i==2 ) break; /* for正常结束，说明p是素数 */
else  p += 2; /* 否则试探下一个奇数 */
}
return p;
}

HashTable CreateTable( int TableSize )
{
HashTable H;
int i;

H = (HashTable)malloc(sizeof(struct TblNode));
/* 保证散列表最大长度是素数 */
H->TableSize = NextPrime(TableSize);
/* 声明单元数组 */
H->Cells = (Cell *)malloc(H->TableSize*sizeof(Cell));
/* 初始化单元状态为“空单元” */
for( i=0; i<H->TableSize; i++ )
H->Cells[i].Info = Empty;

return H;
}

线性探测法

平方探测法（二次探测）

伪代码实现：







C 语言实现： 平方探测法的查找与插入

Position Find( HashTable H, ElementType Key )
{
Position CurrentPos, NewPos;
int CNum = 0; /* 记录冲突次数 */

NewPos = CurrentPos = Hash( Key, H->TableSize ); /* 初始散列位置 */
/* 当该位置的单元非空，并且不是要找的元素时，发生冲突 */
while( H->Cells[NewPos].Info!=Empty && H->Cells[NewPos].Data!=Key ) {
/* 字符串类型的关键词需要 strcmp 函数!! */
/* 统计1次冲突，并判断奇偶次 */
if( ++CNum%2 ){ /* 奇数次冲突 */
NewPos = CurrentPos + (CNum+1)*(CNum+1)/4; /* 增量为+[(CNum+1)/2]^2 */
if ( NewPos >= H->TableSize )
NewPos = NewPos % H->TableSize; /* 调整为合法地址 */
}
else { /* 偶数次冲突 */
NewPos = CurrentPos - CNum*CNum/4; /* 增量为-(CNum/2)^2 */
while( NewPos < 0 )
NewPos += H->TableSize; /* 调整为合法地址 */
}
}
return NewPos; /* 此时NewPos或者是Key的位置，或者是一个空单元的位置（表示找不到）*/
}

bool Insert( HashTable H, ElementType Key )
{
Position Pos = Find( H, Key ); /* 先检查Key是否已经存在 */

if( H->Cells[Pos].Info != Legitimate ) { /* 如果这个单元没有被占，说明Key可以插入在此 */
H->Cells[Pos].Info = Legitimate;
H->Cells[Pos].Data = Key;
/*字符串类型的关键词需要 strcpy 函数!! */
return true;
}
else {
printf("键值已存在");
return false;
}
}

双散列探测法

再散列

11.3.2 分离链接法

伪代码描述：

C 语言实现： 分离链接法的散列表实现

#define KEYLENGTH 15                   /* 关键词字符串的最大长度 */
typedef char ElementType[KEYLENGTH+1]; /* 关键词类型用字符串 */
typedef int Index;                     /* 散列地址类型 */
/******** 以下是单链表的定义 ********/
typedef struct LNode *PtrToLNode;
struct LNode {
ElementType Data;
PtrToLNode Next;
};
typedef PtrToLNode Position;
typedef PtrToLNode List;
/******** 以上是单链表的定义 ********/

typedef struct TblNode *HashTable; /* 散列表类型 */
struct TblNode {   /* 散列表结点定义 */
int TableSize; /* 表的最大长度 */
List Heads;    /* 指向链表头结点的数组 */
};

HashTable CreateTable( int TableSize )
{
HashTable H;
int i;

H = (HashTable)malloc(sizeof(struct TblNode));
/* 保证散列表最大长度是素数，具体见代码5.3 */
H->TableSize = NextPrime(TableSize);

/* 以下分配链表头结点数组 */
H->Heads = (List)malloc(H->TableSize*sizeof(struct LNode));
/* 初始化表头结点 */
for( i=0; i<H->TableSize; i++ ) {
H->Heads[i].Data[0] = '\0';
H->Heads[i].Next = NULL;
}

return H;
}

Position Find( HashTable H, ElementType Key )
{
Position P;
Index Pos;

Pos = Hash( Key, H->TableSize ); /* 初始散列位置 */
P = H->Heads[Pos].Next; /* 从该链表的第1个结点开始 */
/* 当未到表尾，并且Key未找到时 */
while( P && strcmp(P->Data, Key) )
P = P->Next;

return P; /* 此时P或者指向找到的结点，或者为NULL */
}

bool Insert( HashTable H, ElementType Key )
{
Position P, NewCell;
Index Pos;

P = Find( H, Key );
if ( !P ) { /* 关键词未找到，可以插入 */
NewCell = (Position)malloc(sizeof(struct LNode));
strcpy(NewCell->Data, Key);
Pos = Hash( Key, H->TableSize ); /* 初始散列位置 */
/* 将NewCell插入为H->Heads[Pos]链表的第1个结点 */
NewCell->Next = H->Heads[Pos].Next;
H->Heads[Pos].Next = NewCell;
return true;
}
else { /* 关键词已存在 */
printf("键值已存在");
return false;
}
}

void DestroyTable( HashTable H )
{
int i;
Position P, Tmp;

/* 释放每个链表的结点 */
for( i=0; i<H->TableSize; i++ ) {
P = H->Heads[i].Next;
while( P ) {
Tmp = P->Next;
free( P );
P = Tmp;
}
}
free( H->Heads ); /* 释放头结点数组 */
free( H );        /* 释放散列表结点 */
}

11.4 散列表的性能分析

线性探测法的查找性能

平方探测法和双散列探测法的查找性能

期望探测次数与装填因子α 的关系

分离链接法的查找性能

开放地址法与分离链接法的比较

开放地址法：

散列表是一个数组，存储效率高，随机查找。

散列表有“聚集”现象

分离链法：

散列表使顺序存储和链式存储的结合，链表部分的存储效率和查找效率都比较低

关键字删除不需要“懒惰删除”法，从而没有存储“垃圾”

太小的 α 可能导致空间浪费，大的 α 又将付出更多的时间代价。不均匀的链表长度导致时间效率的严重下降。