算法导论小结-散列表

转载 2012年03月27日 16:35:07

By:             潘云登

Date:          2009-7-18

Email:         intrepyd@gmail.com

Homepage: http://blog.csdn.net/intrepyd

Copyright: 该文章版权由潘云登所有。可在非商业目的下任意传播和复制。

对于商业目的下对本文的任何行为需经作者同意。


 

写在前面

1.          本文内容对应《算法导论》(2)》第11章。

2.          主要介绍了散列表的基本概念、散列函数的选择,以及两种解决碰撞的方法(链接法和开放寻址法)。

3.          希望本文对您有所帮助,也欢迎您给我提意见和建议。

4.          本文包含以下内容:

²         散列表的基本概念

²         散列函数

²         解决碰撞的方法

²         完全散列

²         链接法和线性探测实现的散列表


 

散列表的基本概念

假设某应用要用到一个动态集合,其中每个元素都有一个属于[0..p]的关键字,此处p是一个不太大的数,且没有两个元素具有相同的关键字,则可以用一个数组[p+1]存储该动态集合,并且使用关键字作为数组下标进行直接寻址。这一直接寻址思想在前面的非比较排序中就有所应用。然而,当p很大并且实际要存储的动态集合大小n<<p时,这样一个数组将浪费大部分空间。

散列表(Hash table),使用具有m个槽位的数组来存储大小为n的动态集合。α=n/m被定义为散列表的装载因子。在散列表中,具有关键字k的元素的下标为h(k),即利用散列函数h,根据关键字k计算出槽的位置。散列函数h将关键字域[0..p]映射到散列表[0..m-1]的槽位上,这里,m可以远小于p,从而缩小了需要处理的下标范围,并相应地降低了空间开销。散列表带来的问题是:两个关键字可能映射到同一个槽上,这种情形称为碰撞。因此,散列函数h应当将每个关键字等可能地散列到m个槽位的任何一个中去,并与其它关键字已被散列到哪一个槽位中无关,从而避免或者至少最小化碰撞。


 

散列函数

多数散列函数都假定关键字域为自然数集。如果所给关键字不是自然数,则必须有一种方法将它们解释为自然数。这里,介绍三种主要的散列函数:

l          除法散列法:通过取k除以m的余数,来将关键字k映射到m个槽的某一个中去,即散列函数为

h(k) = k mod m

当应用除法散列法时,要注意m的选择,这也是除法散列法的主要缺点。m不应是2的幂,因为如果m=2p,则h(k)就是kp个最低有效位。相反,散列函数应该考虑关键字的所有位。可以选作m的值通常是与2的整数幂不太接近的质数。

l          乘法散列法:首先,用关键字k乘上常数A(0<A<1),并抽取kA的小数部分;然后,用m乘以这个值,再取结果的底(即整数部分)。散列函数可表达为:

h(k) = m(kA mod 1)

乘法方法的一个优点是对m的选择没有特别的要求,一般选择它为2的某个幂次(m=2p)。该方法对任何的A值都适用,但对某些值效果更好。A=(sqrt(5)-1)/2=0.6180339…是一个比较理想的值。

l          全域散列(universal hashing):在执行开始时,从一族仔细设计的函数中,随机地选择一个作为散列函数。这里的随机选择针对的是一次对散列表的应用,而不是一次简单的插入或查找操作。散列函数的确定性,是查找操作正确执行的保证。全域散列法确保,当k!=l时,两者发生碰撞的概率不大于1/m。设计一个全域散列函数类的方法如下,该方法中,散列表大小m的大小是任意的。

选择一个足够大的质数p,使得每一个可能的关键字都落在0p-1的范围内。设Zp表示集合{0, 1, …, p-1}Zp*表示集合{1, 2, …, p-1}。对于任何aZp*和任何bZp,定义散列函数ha,b

ha,b = ((ak+b) mod p) mod m

所有这样的散列函数构成的函数族为:

Hp,m = {ha,b : aZp*bZp}

由于对a来说有p-1种选择,对于b来说有p种选择,因而,Hp,m中共有p(p-1)个散列函数。

 


 

解决碰撞的方法

解决碰撞的方法主要有两种:链接法和开放寻址法。

l          链接法(chaining):把散列到同一槽中的所有元素都存放在一个链表中。每个槽中有一个指针,指向由所有散列到该槽的元素构成的链表的头。如果不存在这样的元素,则指针为空。如果链接法使用的是双向链表,那么删除操作的最坏情况运行时间与插入操作相同,都为O(1),而平均情况下一次成功的查找需要Θ(1+α)时间。

l          开放寻址法(open addressing):所有的元素都存放在散列表中。因此,适用于动态集合大小n不大于散列表大小的情况,即装载因子不超过1。否则,可能发生散列表溢出。在开放寻址中,当要插入一个元素时,可以连续地探查散列表的各项,直到找到一个空槽来放置待插入的关键字。探查的顺序不一定是0, 1, …, m-1,而是要依赖于待插入的关键字k。于是,将探查号作为散列函数的第二个输入参数。为了使所有的槽位都能够被探查到,探查序列<h(k,0), h(k,1), …, h(k,m-1)>必须是<0, 1, …, m-1>的一个排列。有三种技术常用来计算开放寻址法中的探查序列:线性探查、二次探查,以及双重探查。

²         线性探查(linear probing):使用的散列函数如下

h(k,i) = (h’(k) + i) mod m, i=0, 1, …, m-1

h’为一个普通的散列函数,见前面的介绍。线性探查存在一个称为一次群集的问题,即随着时间的推移,连续被占用的槽不断增加,平均查找时间也随着不断增加。但是,线性探查的优点在于,对m的取值没有特殊的要求。

²         二次探查(quadratic probing):使用的散列函数如下

h(k,i) = (h’(k) +c1 i + c2 i2) mod m, i=0, 1, …, m-1

为了能够充分利用散列表,c1c2m的值要受到限制。一种好的选择是,m2某个幂次(m=2p)c1=c2=1/2。二次探查,不会顺序地探查每一个槽位,解决了一次群集问题。但是,如果两个关键字的初始探查位置相同,那么它们的探查序列也是相同的,这一性质导致一种程度较轻的群集现象,称为二次群集。

²         双重散列(double hashing):使用的散列函数如下

h(k,i) = (h1(k) + i h2(k)) mod m, i=0, 1, …, m-1

为能查找整个散列表,值h2(k)要与表的大小m互质。确保这一条件成立的一种方法是取m2的幂,并设计一个总能产生奇数的h2。另一种方法是取m为质数,并设计一个总是产生较m小的正整数的h2。例如,可以取m为质数,h2(k)=1+(k mod m’)m’=m-1


 

完全散列

如果某一种散列技术在进行查找时,其最坏情况内存访问次数为O(1)的话,则称其为完全散列(perfect hashing)。通常利用一种两级的散列方案,每一级上都采用全域散列。为了确保在第二级上不出现碰撞,需要让第二级散列表Sj的大小mj为散列到槽j中的关键字数nj的平方。如果利用从某一全域散列函数类中随机选出的散列函数h,来将n个关键字存储到一个大小为m=n的散列表中,并将每个二次散列表的大小置为mj=nj2 (j=0, 1, …, m-1),则在一个完全散列方案中,存储所有二次散列表所需的存储总量的期望值小于2n


 

附:链接法和线性探测实现的散列表

 

/*

 * chain_hash.c

 * Implement of hash table using chaining method.

 *

 * Author: Yundeng Pan

 * Date:   2009-7-18

 * Email:  intrepyd@gmail.com

 * Blog:   http://blog.csdn.net/intrepyd

 */

#include <stdio.h>

#include <stdlib.h>

#include "chain_hash.h"

 

#define HASH_CONSTANT 0.6180339

 

typedef struct node

{

    int key;

    struct node *prev;

    struct node *next;

}chain_hash_node;

 

chain_hash_node *new_chain_hash_table(int hash_table_size)

{

    int i;

    chain_hash_node *chain_hash_table;

 

    chain_hash_table = malloc(sizeof(chain_hash_node)*hash_table_size);

    for(i=0; i<hash_table_size; i++)

    {

                  chain_hash_table[i].key = 0;

                  chain_hash_table[i].prev = NULL;

                  chain_hash_table[i].next = NULL;

    }

 

    return chain_hash_table;

}

 

void free_chain_hash_table(chain_hash_node *chain_hash_table,

                               int hash_table_size)

{

    int i;

    chain_hash_node *node;

   

    for(i=0; i<hash_table_size; i++)

    {

                  while(chain_hash_table[i].next != NULL)

                  {

                        node = chain_hash_table[i].next;

                        chain_hash_delete(chain_hash_table[i].next);

                        free(node);

                        node = NULL;

                  }

    }

    free(chain_hash_table);

    chain_hash_table = NULL;

}

 

void chain_hash_delete(chain_hash_node *node)

{

    node->prev->next = node->next;

    if(node->next != NULL)

                  node->next->prev = node->prev;

}

 

int chain_hash_func(int hash_table_size, int value)

{

    return (hash_table_size * ((value*HASH_CONSTANT)-(int)(value*HASH_CONSTANT)));

}

 

void chain_hash_insert(chain_hash_node *chain_hash_table,

                          int hash_table_size, int value)

{

    int index;

    chain_hash_node *node;

 

    index = chain_hash_func(hash_table_size, value);

    node = malloc(sizeof(chain_hash_node));

    node->key = value;

    node->prev = &chain_hash_table[index];

    if(chain_hash_table[index].next != NULL)

             chain_hash_table[index].next->prev = node;

    node->next = chain_hash_table[index].next;

    chain_hash_table[index].next = node;

}

 

chain_hash_node *chain_hash_search(chain_hash_node *chain_hash_table,

                                        int hash_table_size, int value)

{

    int index;

    chain_hash_node *node;

 

    index = chain_hash_func(hash_table_size, value);

    node = chain_hash_table[index].next;

    while(node != NULL)

    {

                  if(node->key == value)

                        return node;

                  node = node->next;

    }

 

    return NULL;

}

 

void chain_hash_print(chain_hash_node *chain_hash_table,

                         int hash_table_size)

{

    int i;

    chain_hash_node *node;

 

    printf("/nchain_hash_table:");

    for(i=0; i<hash_table_size; i++)

    {

                  printf("/nslot %d: ", i);

                  node = &chain_hash_table[i];

                  while(node != NULL)

                  {

                        printf("%d ", node->key);

                        node = node->next;

                  }

    }

    printf("/n/n");

}

 

/*

 * probe_hash.c

 * Implement of hash table using linear probing.

 *

 * Author: Yundeng Pan

 * Date:   2009-7-18

 * Email:  intrepyd@gmail.com

 * Blog:   http://blog.csdn.net/intrepyd

 */

#include <stdio.h>

#include <stdlib.h>

#include "probe_hash.h"

 

#define HASH_CONSTANT 0.6180339

#define NIL -1

 

int *new_probe_hash_table(int hash_table_size)

{

    int i, *probe_hash_table;

 

    probe_hash_table = malloc(sizeof(int)*hash_table_size);

    for(i=0; i<hash_table_size; i++)

    {

                  probe_hash_table[i] = NIL;

    }

 

    return probe_hash_table;

}

 

void free_probe_hash_table(int *probe_hash_table)

{

    free(probe_hash_table);

}

 

int probe_inner_hash_func(int hash_table_size, int value)

{

    return (hash_table_size * ((value*HASH_CONSTANT)-(int)(value*HASH_CONSTANT)));

}

 

int probe_hash_func(int hash_table_size, int key, int index)

{

    return (key + index) % hash_table_size;

}

 

int probe_hash_insert(int *probe_hash_table, int hash_table_size, int value)

{

    int i, key, pos;

 

    key = probe_inner_hash_func(hash_table_size, value);

    for(i=0; i<hash_table_size; i++)

    {

                  pos = probe_hash_func(hash_table_size, key, i);

                  if(probe_hash_table[pos] == NIL)

                  {

                        probe_hash_table[pos] = value;

                        return pos;

                  }

    }

 

    printf("Hash table overflow!/n");

    return NIL;

}

 

int probe_hash_search(int *probe_hash_table, int hash_table_size, int value)

{

    int i, key, pos;

 

    key = probe_inner_hash_func(hash_table_size, value);

    for(i=0; i<hash_table_size; i++)

    {

                  pos = probe_hash_func(hash_table_size, key, i);

                  if(probe_hash_table[pos] == NIL)

                        break;

                  if(probe_hash_table[pos] == value)

                        return pos;

    }

 

    printf("Not found!/n");

    return NIL;

}

 

void probe_hash_delete(int *probe_hash_table, int hash_table_size, int value)

{

    int pos;

 

    pos = probe_hash_search(probe_hash_table, hash_table_size, value);

    if(pos != NIL)

                  probe_hash_table[pos] = NIL;

}

 

void probe_hash_print(int *probe_hash_table, int hash_table_size)

{

    int i;

 

    printf("/nprobe_hash_table:");

    for(i=0; i<hash_table_size; i++)

    {

                  printf("/nslot %d: %d", i, probe_hash_table[i]);

    }

    printf("/n/n");

}

 

相关文章推荐

散列表---算法导论第十一章 Hash Tables

一、散列表概念1、 直接寻址表 直接将关键字作为数组下标。复杂度O(1)2、 散列表 k->h(k) 降低了空间开销,会产生碰撞,解决碰撞的简单方法是链接法。 对链接法散列,平均情况...

算法导论11章散列表 思考题总结

11-1 (散列最长探查的界) 采用开放寻址法,用一个大小为 m 的散列表来存储 n ( n a. 假设采用均匀散列,证明:对于 i = 1,2,... ,n,第 i 次插入需要严格多于 k 次探查...

算法导论---------------散列表(hash table)

摘要:   本章介绍了散列表(hash table)的概念、散列函数的设计及散列冲突的处理。散列表类似与字典的目录,查找的元素都有一个key与之对应,在实践当中,散列技术的效率是很高的,合理的设...

学习《算法导论》第十一章 散列表 总结二

学习《算法导论》第十一章 散列表 总结二本节学习散列表的两种实现方法:链接法和开放寻址法的代码实现.链接法hashsep.h#ifndef _HashSep_Htypedef int ElementT...

《算法导论》第11章 散列表 (1)直接寻址表

(一)直接寻址表 关键字集合U = { 0, 1, ..., m - 1 },实际的关键字集合K。 用一个数组T[0..m - 1],其中每个位置对应U中的一个关键字。 ...
  • dc_726
  • dc_726
  • 2012-03-07 22:54
  • 3797

算法导论11.2散列表 练习总结

11.2-1 假设用一个散列函数 h 将 n 个不同的关键字散列刀一个长度为 m 的数组 T 中。假设采用的是简单均匀散列,那么期望的冲突数是多少?更准确地,集合 { { k,l } :k ≠ l,且...

散列表的学习和探讨(算法导论第11章)

许多的应用需要一个动态的集合结构,它至少支持INSERT、SEARCH和DELETE的字典操作。散列表是实现了字典操作的一种有效数据结构。尽管最坏情况下散列表查找一个元素的时间与链表的查找时间相同,达...

散列表的详细剖析 (算法导论第11章)

注意:   ① 由同一个散列函数、不同的解决冲突方法构造的散列表,其平均查找长度是不相同的。   ② 散列表的平均查找长度不是结点个数n的函数,而是装填因子α的函数。因此在设计散列表时可选择α以控制散...

算法导论-第11章-散列表-11.1-4 大数组的直接寻址表

一、题目 我们希望我们希望通过利用在一个非常大的数组上直接寻址的方式来实现字典。开始时,该数组中可能包含废料,但要对整个数组进行初始化是不实际的,因为该数组的规模太大。请给出在大数组上实现直接寻址字...

《算法导论》第11章 散列表 (3)开放寻址

前一节介绍是最简单的冲突解决方法-链接法。开放寻址与链接法不同,所有元素都放在散列表内。 在这种方法中,散列表可能会被填满。开放寻址不需要指针,只需要计算出要存取的各个槽。 由于不用存储指针而节省...
  • dc_726
  • dc_726
  • 2012-03-12 21:34
  • 2218
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)