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

11.1 散列表（哈希表）

11.1.1 散列的基本思路

散列查找。

先讲一个例子：

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

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

• 插入：新变量的定义
• 查找：变量的引用
• 还有可能有删除变量的操作

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

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

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

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

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

• 有序安排对象：全序（二分查找）、半序（查找树）
• 直接“算出”对象位置：散列

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

• 计算位置：构造散列函数确定关键词存储位置
• 解决冲突：应用某种策略解决多个关键词位置相同的问题

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

11.1.2 什么是散列表

散列的基本思想 是：

例子：

11.2 散列函数的构造方式

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

1. 计算简单，以便提高转换速度
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 散列表的性能分析

线性探测法的查找性能

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

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

分离链接法的查找性能

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

开放地址法：

• 散列表是一个数组，存储效率高，随机查找。
• 散列表有“聚集”现象

分离链法：

• 散列表使顺序存储和链式存储的结合，链表部分的存储效率和查找效率都比较低
• 关键字删除不需要“懒惰删除”法，从而没有存储“垃圾”
• 太小的 α 可能导致空间浪费，大的 α 又将付出更多的时间代价。不均匀的链表长度导致时间效率的严重下降。