散列表（哈希表HASH）

散列表（哈希表HASH）

对于结构体中可能包含多种类型的对象，因而不适合利用avl等方法来进行操作。
查找的本质：已知对象找位置。
·排序：有序、半序；
·直接“算出”对象的位置：散列。

两项基本工作

计算位置：构造散列函数集散关键词对应的储存位置；

以关键字key为自变量，确定一个函数h（散列函数），计算出其对应的h（key）值（计算方法，可视具体情况而定。），作为数据对象的存储位置。

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

散列函数的构造

直接定址法

取关键词的某个线性值为散列地址。如h（key ） = a*key+b

除数留余法

h（key ） = key mod p ；p一般取素数；（因此，可以得到结论，如果除数取了合数，那么以它的任何一个因子作为间隔的数列都将产生严重的散列冲突，因数越多，发生这种冲突的数列越多。）

数字分析法

分析数字关键字的各位的变化情况，取比较随机的几位作为散列地址。
如h（key） = atoi（key+n），第n位；

折叠法

把关键字分为几部分，后进行相加，值作为其散列地址；

平方取中法

将关键字取平方，选取其中间几位作为散列地址

无论那种方法，其目的均是尽可能使关键字随机，符合其整体，降低冲突的可能性。

字符关键字的散列函数的构造

好的散列函数，可采用移位法。涉及到关键词的所有字符，并且分布良好。

冲突处理方法

开放地址法（open addressing）

产生冲突后，按照某种规则去寻找另一空地址。
如发生了第i次位置处的冲突，可在该位置的基础上增加（减少）di，即hi（key） = （h（key）+ di） mod tablesize；
di的选取可采用线性探测、平方探测（±di2）、双散列（i*h2（key））；

线性探测（linear probing）及评价指标（性能分析）

有“聚集”现象；（冲突会越聚越多）

成功 平均查找长度（ASLs）

查找表中关键词的平均查找长度；（每个关键词的查找次数为其冲突次数+1）

不成功平均查找长度（ASLu）

对于不在表中的元素，将其分类，根据求余后的值作为h（key）进行查找，直到遇到一个空位为止；
此例子中为分为0-10,11中情况；

平方探测法（quadratic probing）

冲突次数为某key值在h（key）处开始每次查询的次数+1/-1/+4，查询末端若有冲突则算作冲突次数；
减轻“聚集”现象；
如果表的长度为4k+3形式的素数时，平方探测法一定可以探查到整个散列表的空间。
部分代码实现

#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;
}

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;
    }
}

双散列探测法（Double Hashing）

双散列为i*h2（key），h2（key）为另一个散列函数，探测序列为h2（key），2h2（key）~~····；且不为0；
对于h2（key） = p - （key mod p）形式，具有良好效果，p < tablesize,且为素数

再散列（Rehashing）

当散列表中的元素太多时，（装填因子a = 散列表中的元素数/tablesize 过大），查找效率会下降。
实用的a ： 0.5<= a <= 0.85
当装填因子过大时，解决方法需重新扩大散列表，其中的元素需重新计算；

链地址法

分离链接法（separate chaining）

部分代码实现

#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); //nextprime 的具体函数参见quadratic probing；

    /* 以下分配链表头结点数组 */
    H->Heads = (List)malloc(H->TableSize*sizeof(struct LNode)); //heads为结点数组；
    /* 初始化表头结点 */
    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 );        /* 释放散列表结点 */
}

散列表的性能分析

平均查找长度（ASL）来决定散列表的查找效率。
关键词的查找，取决于冲突的次数。冲突的次数由以下几方面的影响：
（1）散列函数是否均匀
（2）处理冲突的方法
（3）散列表的装填因子a

线性

quadratic probing/double hashing

分离链接法

总结

（1）在选择合适的h（key）函数的情况下，散列发的查找期望为常数o（1），与查找规模无关。
（2）由于查找效率与a有关，因而是以较小的a为前提，即以空间换时间；
（3）散列方法的存储对于关键字是随机的，因而难以按顺序查找max、min及范围查找；

开放地址法，以数组为依托，存储效率高，随机存储。有“聚集”现象；
分离链接法，是顺序存储和链表存储的结合，存储效率较低，关键字的删除不需要“懒惰删除”，无存储“垃圾”。； a过小会造成存储空间浪费，a太大，时间过长，不均匀的链表长度会导致时间效率下降。