MIT算法导论第七讲学习笔记-哈希表(Hashing)

于 2018-07-05 15:50:01 发布
阅读量219 收藏 1
点赞数 1
分类专栏： 算法

MIT算法导论学习第七讲+第八讲：哈希表

-1哈希表的定义

哈希表，又称散列表，其定义是根据一个哈希函数将集合S中的关键字映射到一个表中，这个表就称为哈希表，而这种方法就称为Hashing。

1.1引入哈希表

我们先来一个直观的理解：如果一个集合S中的关键字

并且关键字各不相同，那么我们按如下公式建立一个Array T[0,1…m-1]：

这个公式什么意思呢？就是我们建立这样的一个表，对于关键字k，我们把它存储在T[k]，的位置上，那么对他们的访问用时为O(1)，不需查找。

这个方法有一个缺点，如果关键字的范围比较大(如：0~2^32-1,32位所能表示的最大长度)，那么我们建立的这个表的长度那么就大到无法接受了。假设有两个关键字：0和2^32，那么按上述的方法就要直接建立一个长度为2^32的表，显然这是不现实的。

怎么解决呢？？这便是哈希表的引入。

哈希表就是把上述的直接映射，变成一个函数映射，这个函数就是哈希函数，如下图：

此时再来看哈希函数，哈希函数就是你给我一个值，我就能通过这个函数计算出它的存储地址，然后就能进行操作了。哈希表做到了什么呢？哈希表可以使得在表小的情况下仍能够保存数据，并且能够在常数时间O(1)内完成查询。为什么是常数时间呢？因为我们不需要比较，不需要遍历查找，只要计算出地址，有待查询的值那么就找到了；没有，那么表中就不存在。

1.2 怎样设计哈希函数

当然现实中要操作的不止两个元素，那么我们怎样设计一个哈希函数呢？？

这里有两个要点：

一个好的哈希函数应该能够将关键字均匀的分配到哈希表T中；

而关键字的分布率不应该影响这种均匀性。

第二点也许现在还不能很好的理解，先放下，先看一个最常用的哈希函数：

 1.3除模取余法

假设所有关键字k属于K都是整数，定义：

这个函数依赖于对除数m的选择，一般选择m是一个质数，并且与2或者10的幂次不靠近(因为这两个是日常缩减的最能体现规律性数的基数)。其 缺陷 在于除法在机器中需要更多的时钟周期完成。

来看两个不好的m的选择：

1. m=2时，如果所有的关键字都是偶数，这时会有什么后果呢？？

表中的所有的奇数位置都没用到，这便是关键字的分布规律(全偶)影响到了映射的均匀性。

2. 再看，当m=2^r时，我们把关键字用二进制表示，那么如下的一个关键字：

只与后六位有关。

-2 哈希函数的分析

我们来对上述的方法进行分析。
假设我们要将12个数映射到一个哈希表，将表长定义为13(质数)，如下图所示

按照上述方法，前四个都没有问题，都映射到了对应的位置，但是第5个关键字25和第一个关键字都映射到了位置12，这怎么办呢？？
当一个待插入的关键字映射到一个已经被占用的位置时，便产生了一次冲突(Collision)， 冲突可以通过选择好的哈希函数来减少，但是很难完全避免冲突 。

怎样解决冲突呢？？？

-3 冲突解决方法

3.1 开放地址法

一有冲突那么便去寻找下一个空的地址，只要表足够大，空的地址总能找到，即：

e.g. 

上面25在12的位置上发生了冲突，那么便去寻找下一个位置，即

那么便把25存储在0的位置上。

再继续往下时，关键字29又与16发生了冲突，都映射到了位置3，那么继续用上面的方法：

而在4的位置又与56，发生了冲突，那么继续：

这样在5的位置终于有了位置，存储在位置5.

其他的以此类推。

值得注意的是，当di选择不同时，有不同的探查方法(寻找空位的方法)，这里注重思想的理解，其他方法便略去了。

3.2 拉链法(链地址法)

上述的方法是一出现冲突就换地方，那么一个想法是：凭什么它在那儿而我要换呢？？

链地址法就是不换地址，而是在原来的位置后面加一个节点，如下图：

以后的冲突就这样解决了，而且这种方法有一个优点，就是不管有多少冲突它都能解决。

然而，优点也是缺点，假设所有的关键字都映射到了一个位置，那么后果就是这个散列表退化成了链表，查找链表的时间是O(n)，这可不是散列表的初衷。

3.3 公共溢出区

这个方法更好理解，所有的有冲突的都去一个事先开辟好的空间，叫做公共溢出区。这样当25与12发生冲突了，那么25便去公共溢出区去呆着了，在查找的时候除了要查询映射到基本表的位置外，还要查找公共溢出区，这样没找到才是真的没有了。

理解了哈希思想后，我们再看其他的常用哈希函数构造方法：直接定址法、数字分析法、平方取中法、折叠法、随机数法等。这些方法在理解了哈希思想之后就会发现它只是一个映射地址的函数，在不同的情况下可能某个性能更好。

-4 代码实现

本节我们对上述的例子进行代码实现，采用除留取余法作为哈希函数，采用开放地址法来解决冲突。

4.1 分段代码

首先，定义表长13，并且，定义一个表示空表的数-32768，和哈希表的结构，定义如下：

  1. typedef int datatType ;
  2. #define HashSize 13
  3. #define NULLKEY -32768
  4. /*Hash Table*/
  5. typedef struct
  6. {
  7. int elem[HashSize] ;
  8. int count ;
  9. }HashTable;

其次是哈希函数：

  1. /*Hashing_Mod*/
  2. int Hashing_Mod(datatType key)
  3. {
  4. return key%HashSize ;
  5. }

然后，我们定义插入函数：

  1. /*HashInsert*/
  2. void HashInsert(HashTable *H, datatType key)
  3. {
  4. int addr = Hashing_Mod(key) ;
  5. while (H->elem[addr] != NULLKEY)
  6. {
  7. addr = (addr + 1)% HashSize ;
  8. }
  9. H->elem[addr] = key ;
  10. }

最后，我们定义查找函数：

  1. /*SearchHashTable*/
  2. int SearchHashTable(HashTable *H, datatType key, int *addr)
  3. {
  4. *addr = Hashing_Mod(key) ;
  6. while(H->elem[*addr] != key)
  7. {
  8. *addr = (*addr + 1)% HashSize ;
  9. if (H->elem[*addr] == NULLKEY || *addr == Hashing_Mod(key))
  10. {
  11. return 0 ;
  12. }
  13. }
  14. return 1 ;
  15. }

4.2 整体代码

整个代码如下：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. typedef int datatType ;
  5. #define HashSize 13
  6. #define NULLKEY -32768
  8. /*Hash Table*/
  9. typedef struct
  10. {
  11. int elem[HashSize] ;
  12. int count ;
  13. }HashTable;
  14. /*InitHashTable*/
  15. int InitHashTable(HashTable *&H)
  16. {
  18. H = (HashTable *) malloc( sizeof(HashTable)) ;
  19. H->count = HashSize ;
  20. int i ;
  21. //H->elem = (int *)malloc(HashSize*sizeof(int)) ;
  22. for(i = 0; i < HashSize; i ++)
  23. H->elem[i] = NULLKEY ;
  25. return 1 ;
  26. }
  28. /*Hashing_Mod*/
  29. int Hashing_Mod(datatType key)
  30. {
  31. return key%HashSize ;
  32. }
  34. /*HashInsert*/
  35. void HashInsert(HashTable *H, datatType key)
  36. {
  37. int addr = Hashing_Mod(key) ;
  38. while (H->elem[addr] != NULLKEY)
  39. {
  40. addr = (addr + 1)% HashSize ;
  41. }
  42. H->elem[addr] = key ;
  43. }
  45. /*SearchHashTable*/
  46. int SearchHashTable(HashTable *H, datatType key, int *addr)
  47. {
  48. *addr = Hashing_Mod(key) ;
  50. while(H->elem[*addr] != key)
  51. {
  52. *addr = (*addr + 1)% HashSize ;
  53. if (H->elem[*addr] == NULLKEY || *addr == Hashing_Mod(key))
  54. {
  55. return 0 ;
  56. }
  57. }
  58. return 1 ;
  59. }
  60. //==================Auxiliary Code=================
  61. /*PrintArray*/
  62. void PrintArray(datatType *A, int n)
  63. {
  64. int i ;
  65. for (i = 0; i < n; i ++)
  66. {
  67. printf( "%d\t",A[i]) ;
  68. }
  69. printf( "\n") ;
  70. }
  72. int main()
  73. {
  74. //===================hashing================
  75. HashTable *H ;
  76. InitHashTable(H) ;
  77. int key[] = { 12, 67, 56, 16, 25, 37, 22, 29, 15, 47, 48, 34} ;
  78. for( int i = 0; i < HashSize - 1; i ++)
  79. {
  80. HashInsert(H,key[i]) ;
  81. }
  82. PrintArray(H->elem,HashSize) ;
  83. int *addr = ( int *) malloc( sizeof( int)) ;
  84. int ans = SearchHashTable(H, 47,addr) ;
  85. if ( 0 == ans)
  86. {
  87. printf( "No Match !\n") ;
  88. }
  89. else
  90. {
  91. printf( "Key is hashed at: %d\n",*addr) ;
  92. }
  93. return 0 ;
  94. }

4.3程序运行结果与分析

程序查找的是47，在位置8(是从0开始的)。

注意上述的查找方法，查找结束的条件是要么找到了空的位置(有空位子没有填充，说明表里没有这个关键字，因为如果有的话它不会隔着一个空的位置来找下一个位置的，因为是线性查询。)，要么查询返回了初始映射位置(说明找了一圈所有可能的位置都没有)。

我们查找一个不存在的关键字55，结果如下：

最后采用这种方法最终构建的哈希表为：

拾破烂的小孩
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值