《算法导论》读书笔记之第11章 散列表

本章介绍了散列表(hash table)的概念、散列函数的设计及散列冲突的处理。散列表类似与字典的目录,查找的元素都有一个key与之对应,在实践当中,散列技术的效率是很高的,合理的设计散函数和冲突处理方法,可以使得在散列表中查找一个元素的期望时间为O(1)。散列表是普通数组概念的推广,在散列表中,不是直接把关键字用作数组下标,而是根据关键字通过散列函数计算出来的。书中介绍散列表非常注重推理和证明,看的时候迷迷糊糊的,再次证明了数学真的很重要。在STL中map容器的功能就是散列表的功能,但是map采用的是红黑树实现的,后面接着学习,关于map的操作可以参考:http://www.cplusplus.com/reference/map/

1、直接寻址表

  当关键字的的全域(范围)U比较小的时,直接寻址是简单有效的技术,一般可以采用数组实现直接寻址表,数组下标对应的就是关键字的值,即具有关键字k的元素被放在直接寻址表的槽k中。直接寻址表的字典操作实现比较简单,直接操作数组即可以,只需O(1)的时间。

2、散列表

  直接寻址表的不足之处在于当关键字的范围U很大时,在计算机内存容量的限制下,构造一个存储|U|大小的表不太实际。当存储在字典中的关键字集合K比所有可能的关键字域U要小的多时,散列表需要的存储空间要比直接寻址表少的很多。散列表通过散列函数h计算出关键字k在槽的位置。散列函数h将关键字域U映射到散列表T[0....m-1]的槽位上。即h:U->{0,1...,m-1}。采用散列函数的目的在于缩小需要处理的小标范围,从而降低了空间的开销。

  散列表存在的问题:两个关键字可能映射到同一个槽上,即碰撞(collision)。需要找到有效的办法来解决碰撞。

3、散列函数

  好的散列函数的特点是每个关键字都等可能的散列到m个槽位上的任何一个中去,并与其他的关键字已被散列到哪一个槽位无关。多数散列函数都是假定关键字域为自然数N={0,1,2,....},如果给的关键字不是自然数,则必须有一种方法将它们解释为自然数。例如对关键字为字符串时,可以通过将字符串中每个字符的ASCII码相加,转换为自然数。书中介绍了三种设计方案:除法散列法、乘法散法和全域散列法。

(1)除法散列法

  通过取k除以m的余数,将关键字k映射到m个槽的某一个中去。散列函数为:h(k)=k mod m 。m不应是2的幂,通常m的值是与2的整数幂不太接近的质数。

(2)乘法散列法

  这个方法看的时候不是很明白,没有搞清楚什么意思,先将基本的思想记录下来,日后好好消化一下。乘法散列法构造散列函数需要两个步骤。第一步,用关键字k乘上常数A(0<A<1),并抽取kA的小数部分。然后,用m乘以这个值,再取结果的底。散列函数如下:h(k) = m(kA mod 1)。

(3)全域散列

  给定一组散列函数H,每次进行散列时候从H中随机的选择一个散列函数h,使得h独立于要存储的关键字。全域散列函数类的平均性能是比较好的。

4、碰撞处理

  通常有两类方法处理碰撞:开放寻址(Open Addressing)法和链接(Chaining)法。前者是将所有结点均存放在散列表T[0..m-1]中;后者通常是把散列到同一槽中的所有元素放在一个链表中,而将此链表的头指针放在散列表T[0..m-1]中。

(1)开放寻址法

  所有的元素都在散列表中,每一个表项或包含动态集合的一个元素,或包含NIL。这种方法中散列表可能被填满,以致于不能插入任何新的元素。在开放寻址法中,当要插入一个元素时,可以连续地检查或探测散列表的各项,直到有一个空槽来放置待插入的关键字为止。有三种技术用于开放寻址法:线性探测、二次探测以及双重探测。

<1>线性探测

  给定一个普通的散列函数h‘:U —>{0,1,.....,m-1},线性探测方法采用的散列函数为:h(k,i) = (h‘(k)+i)mod m,i=0,1,....,m-1  

探测时从i=0开始,首先探查T[h‘(k)],然后依次探测T[h‘(k)+1],…,直到T[h‘(k)+m-1],此后又循环到T[0],T[1],…,直到探测到T[h‘(k)-1]为止。探测过程终止于三种情况: 
  (1)若当前探测的单元为空,则表示查找失败(若是插入则将key写入其中); 
  (2)若当前探测的单元中含有key,则查找成功,但对于插入意味着失败; 
  (3)若探测到T[h‘(k)-1]时仍未发现空单元也未找到key,则无论是查找还是插入均意味着失败(此时表满)。

线性探测方法较容易实现,但是存在一次群集问题,即连续被占用的槽的序列变的越来越长。采用例子进行说明线性探测过程,已知一组关键字为(26,36,41,38,44,15,68,12,6,51),用除余法构造散列函数,初始情况如下图所示:

散列过程如下图所示:

<2>二次探测

  二次探测法的探查序列是:h(k,i) =(h‘(k)+i*i)%m ,0≤i≤m-1 。初次的探测位置为T[h‘(k)],后序的探测位置在次基础上加一个偏移量,该偏移量以二次的方式依赖于i。该方法的缺陷是不易探查到整个散列空间。

<3>双重散列

  该方法是开放寻址的最好方法之一,因为其产生的排列具有随机选择的排列的许多特性。采用的散列函数为:h(k,i)=(h1(k)+ih2(k)) mod m。其中h1和h2为辅助散列函数。初始探测位置为T[h1(k)],后续的探测位置在此基础上加上偏移量h2(k)模m。

(2)链接法

  将所有关键字为同义词的结点链接在同一个链表中。若选定的散列表长度为m,则可将散列表定义为一个由m个头指针组成的指针数组T[0..m-1]。凡是散列地址为i的结点,均插入到以T[i]为头指针的单链表中。T中各分量的初值均应为空指针。在拉链法中,装填因子α可以大于1,但一般均取α≤1。

  举例说明链接法的执行过程,设有一组关键字为(26,36,41,38,44,15,68,12,6,51),用除余法构造散列函数,初始情况如下图所示:

最终结果如下图所示:

5、字符串散列

  通常都是将元素的key转换为数字进行散列,如果key本身就是整数,那么散列函数可以采用keymod tablesize(要保证tablesize是质数)。而在实际工作中经常用字符串作为关键字,例如身姓名、职位等等。这个时候需要设计一个好的散列函数进程处理关键字为字符串的元素。参考《数据结构与算法分析》第5章,有以下几种处理方法:

方法1:将字符串的所有的字符的ASCII码值进行相加,将所得和作为元素的关键字。设计的散列函数如下所示:

1 int hash(const string& key,int tablesize)
2 {
3     int hashVal = 0;
4     for(int i=0;i<key.length();i++)
5            hashVal += key[i];
6     return hashVal % tableSize;
7 }

  此方法的缺点是不能有效的分布元素,例如假设关键字是有8个字母构成的字符串,散列表的长度为10007。字母最大的ASCII码为127,按照方法1可得到关键字对应的最大数值为127×8=1016,也就是说通过散列函数映射时只能映射到散列表的槽0-1016之间,这样导致大部分槽没有用到,分布不均匀,从而效率低下。

方法2:假设关键字至少有三个字母构成,散列函数只是取前三个字母进行散列。设计的散列函数如下所示:

1 int hash(const string& key,int tablesize)
2 {
3         //27 represents the number of letters plus the blank
4         return (key[0]+27*key[1]+729*key[2])%tablesize;
5 }

  该方法只是取字符串的前三个字符的ASCII码进行散列,最大的得到的数值是2851,如果散列的长度为10007,那么只有28%的空间被用到,大部分空间没有用到。因此如果散列表太大,就不太适用。

方法3:借助Horner‘s 规则,构造一个质数(通常是37)的多项式,(非常的巧妙,不知道为何是37)。计算公式为:key[keysize-i-1]37^i,0<=i<keysize求和。设计的散列函数如下所示:

 1 int hash(const string & key,int tablesize)
 2 {
 3         int hashVal = 0;
 4         for(int i =0;i<key.length();i++)
 5             hashVal = 37*hashVal + key[i];
 6         hashVal %= tableSize;
 7         if(hashVal<0)  //计算的hashVal溢出 8            hashVal += tableSize;
 9        return hashVal;
10 }

  该方法存在的问题是如果字符串关键字比较长,散列函数的计算过程就变长,有可能导致计算的hashVal溢出。针对这种情况可以采取字符串的部分字符进行计算,例如计算偶数或者奇数位的字符。

6、再散列(rehashing)

  如果散列表满了,再往散列表中插入新的元素时候就会失败。这个时候可以通过创建另外一个散列表,使得新的散列表的长度是当前散列表的2倍多一些,重新计算各个元素的hash值,插入到新的散列表中。再散列的问题是在什么时候进行最好,有三种情况可以判断是否该进行再散列:

(1)当散列表将快要满了,给定一个范围,例如散列被中已经被用到了80%,这个时候进行再散列。

(2)当插入一个新元素失败时候,进行再散列。

(3)根据装载因子(存放n个元素的、具有m个槽位的散列表T,装载因子α=n/m,即每个链子中的平均存储的元素数目)进行判断,当装载因子达到一定的阈值时候,进行在散列。

  在采用链接法处理碰撞问题时,采用第三种方法进行在散列效率最好。

7、实例练习

  看完书后,有一股想把hash表实现的冲动。在此设计的散列表针对的是关键字为字符串的元素,采用字符串散列函数方法3进行设计散列函数,采用链接方法处理碰撞,然后采用根据装载因子(指定为1,同时将n个元素映射到一个链表上,即n==m时候)进行再散列。采用C++,借助vector和list,设计的hash表框架如下:

 1 template <class T>
 2 class HashTable
 3 {
 4 public:
 5     HashTable(int size = 101);
 6     int insert(const T& x);
 7     int remove(const T& x);
 8     int contains(const T& x);
 9     void make_empty();
10     void display()const;
11 private:
12     vector<list<T> > lists;
13     int currentSize;//当前散列表中元素的个数
14     int hash(const string& key);
15     int myhash(const T& x);
16     void rehash();
17 };

实现的完整程序如下所示:

  1 #include <iostream>
  2 #include <vector>
  3 #include <list>
  4 #include <string>
  5 #include <cstdlib>
  6 #include <cmath>
  7 #include <algorithm>
  8 using namespace std;
  9
 10 int nextPrime(const int n);
 11
 12 template <class T>
 13 class HashTable
 14 {
 15 public:
 16     HashTable(int size = 101);
 17     int insert(const T& x);
 18     int remove(const T& x);
 19     int contains(const T& x);
 20     void make_empty();
 21     void display()const;
 22 private:
 23     vector<list<T> > lists;
 24     int currentSize;
 25     int hash(const string& key);
 26     int myhash(const T& x);
 27     void rehash();
 28 };
 29
 30 template <class T>
 31 HashTable<T>::HashTable(int size)
 32 {
 33     lists = vector<list<T> >(size);
 34     currentSize = 0;
 35 }
 36
 37 template <class T>
 38 int HashTable<T>::hash(const string& key)
 39 {
 40     int hashVal = 0;
 41     int tableSize = lists.size();
 42     for(int i=0;i<key.length();i++)
 43         hashVal = 37*hashVal+key[i];
 44     hashVal %= tableSize;
 45     if(hashVal < 0)
 46         hashVal += tableSize;
 47     return hashVal;
 48 }
 49
 50 template <class T>
 51 int HashTable<T>:: myhash(const T& x)
 52 {
 53     string key = x.getName();
 54     return hash(key);
 55 }
 56 template <class T>
 57 int HashTable<T>::insert(const T& x)
 58 {
 59     list<T> &whichlist = lists[myhash(x)];
 60     if(find(whichlist.begin(),whichlist.end(),x) != whichlist.end())
 61         return 0;
 62     whichlist.push_back(x);
 63     currentSize = currentSize + 1;
 64     if(currentSize > lists.size())
 65         rehash();
 66     return 1;
 67 }
 68
 69 template <class T>
 70 int HashTable<T>::remove(const T& x)
 71 {
 72
 73     typename std::list<T>::iterator iter;
 74     list<T> &whichlist = lists[myhash(x)];
 75     iter = find(whichlist.begin(),whichlist.end(),x);
 76     if( iter != whichlist.end())
 77     {
 78           whichlist.erase(iter);
 79           currentSize--;
 80           return 1;
 81     }
 82     return 0;
 83 }
 84
 85 template <class T>
 86 int HashTable<T>::contains(const T& x)
 87 {
 88     list<T> whichlist;
 89     typename std::list<T>::iterator iter;
 90     whichlist = lists[myhash(x)];
 91     iter = find(whichlist.begin(),whichlist.end(),x);
 92     if( iter != whichlist.end())
 93           return 1;
 94     return 0;
 95 }
 96
 97 template <class T>
 98 void HashTable<T>::make_empty()
 99 {
100     for(int i=0;i<lists.size();i++)
101         lists[i].clear();
102     currentSize = 0;
103     return 0;
104 }
105
106 template <class T>
107 void HashTable<T>::rehash()
108 {
109     vector<list<T> > oldLists = lists;
110     lists.resize(nextPrime(2*lists.size()));
111     for(int i=0;i<lists.size();i++)
112         lists[i].clear();
113     currentSize = 0;
114     for(int i=0;i<oldLists.size();i++)
115     {
116         typename std::list<T>::iterator iter = oldLists[i].begin();
117         while(iter != oldLists[i].end())
118             insert(*iter++);
119     }
120 }
121 template <class T>
122 void HashTable<T>::display()const
123 {
124     for(int i=0;i<lists.size();i++)
125     {
126         cout<<i<<": ";
127         typename std::list<T>::const_iterator iter = lists[i].begin();
128         while(iter != lists[i].end())
129         {
130             cout<<*iter<<" ";
131             ++iter;
132         }
133         cout<<endl;
134     }
135 }
136 int nextPrime(const int n)
137 {
138     int ret,i;
139     ret = n;
140     while(1)
141     {
142         int flag = 1;
143         for(i=2;i<sqrt(ret);i++)
144             if(ret % i == 0)
145             {
146                 flag = 0;
147                 break;
148             }
149         if(flag == 1)
150             break;
151         else
152         {
153             ret = ret +1;
154             continue;
155         }
156     }
157     return ret;
158 }
159
160 class Employee
161 {
162 public:
163     Employee(){}
164     Employee(const string n,int s=0):name(n),salary(s){ }
165     const string & getName()const  { return name; }
166     bool operator == (const Employee &rhs) const
167     {
168         return getName() == rhs.getName();
169     }
170     bool operator != (const Employee &rhs) const
171     {
172         return !(*this == rhs);
173     }
174     friend ostream& operator <<(ostream& out,const Employee& e)
175     {
176         out<<"("<<e.name<<","<<e.salary<<") ";
177         return out;
178     }
179 private:
180     string name;
181     int salary;
182 };
183
184 int main()
185 {
186     Employee e1("Tom",6000);
187     Employee e2("Anker",7000);
188     Employee e3("Jermey",8000);
189     Employee e4("Lucy",7500);
190     HashTable<Employee> emp_table(13);
191
192     emp_table.insert(e1);
193     emp_table.insert(e2);
194     emp_table.insert(e3);
195     emp_table.insert(e4);
196
197     cout<<"Hash table is: "<<endl;
198     emp_table.display();
199     if(emp_table.contains(e4) == 1)
200         cout<<"Tom is exist in hash table"<<endl;
201     if(emp_table.remove(e1) == 1)
202           cout<<"Removing Tom form the hash table successfully"<<endl;
203     if(emp_table.contains(e1) == 1)
204         cout<<"Tom is exist in hash table"<<endl;
205     else
206         cout<<"Tom is not exist in hash table"<<endl;
207     //emp_table.display();
208     exit(0);
209 }

程序测试结果如下所示:

参考:http://www.cnblogs.com/zhanglanyun/archive/2011/09/01/2161729.html

时间: 2024-11-06 13:01:24

《算法导论》读书笔记之第11章 散列表的相关文章

算法导论读书笔记-第十四章-数据结构的扩张

算法导论第14章 数据结构的扩张 一些工程应用需要的只是标准数据结构, 但也有许多其他的应用需要对现有数据结构进行少许的创新和改造, 但是只在很少情况下需要创造出全新类型的数据结构, 更经常的是通过存储额外信息的方法来扩张一种标准的数据结构, 然后对这种数据结构编写新的操作来支持所需要的应用. 但是对数据结构的扩张并不总是简单直接的, 因为新的信息必须要能被该数据结构上的常规操作更新和维护. 14.1 动态顺序统计 顺序统计树(order-static tree) : 在红黑树的基础上, 在每个

算法导论读书笔记(13)

算法导论读书笔记(13) 目录 红黑树 旋转 插入 情况1 : z 的叔父结点 y 是红色的 情况2 : z 的叔父结点 y 是黑色的,而且 z 是右孩子 情况3 : z 的叔父结点 y 是黑色的,而且 z 是左孩子 删除 情况1 : x 的兄弟 w 是红色的 情况2 : x 的兄弟 w 是黑色的,且 w 的两个孩子都是黑色的 情况3 : x 的兄弟 w 是黑色的, w 的左孩子是红色的,右孩子是黑色的 情况4 : x 的兄弟 w 是黑色的,且 w 的右孩子是红色的 红黑树 红黑树 是一种二叉查

算法导论读书笔记(18)

算法导论读书笔记(18) 目录 最长公共子序列 步骤1:描述最长公共子序列的特征 步骤2:一个递归解 步骤3:计算LCS的长度 步骤4:构造LCS LCS问题的简单Java实现 最长公共子序列 某给定序列的子序列,就是将给定序列中零个或多个元素去掉后得到的结果.其形式化定义如下:给定一个序列 X = < x1 , x2 , - , xm >,另一个序列 Z = < z1 , z2 , - , zk >,如果 Z 满足如下条件则称 Z 为 X 的 子序列 (subsequence),

算法导论读书笔记之钢条切割问题

算法导论读书笔记之钢条切割问题 巧若拙(欢迎转载,但请注明出处:http://blog.csdn.net/qiaoruozhuo) 给定一段长度为n英寸的钢条和一个价格表 pi (i=1,2, -,n),求切割钢条的方案,使得销售收益rn最大.注意,如果长度为n英寸的钢条价格pn足够大,最优解可能就是完全不需要切割. 若钢条的长度为i,则钢条的价格为Pi,如何对给定长度的钢条进行切割能得到最大收益? 长度i   1   2    3   4     5      6     7     8  

算法导论读书笔记(15) - 红黑树的具体实现

算法导论读书笔记(15) - 红黑树的具体实现 目录 红黑树的简单Java实现 红黑树的简单Java实现 /** * 红黑树 * * 部分代码参考自TreeMap源码 */ public class RedBlackTree<T> { protected TreeNode<T> root = null; private final Comparator<? super T> comparator; private int size = 0; private static

算法导论读书笔记(17)

算法导论读书笔记(17) 目录 动态规划概述 钢条切割 自顶向下的递归实现 使用动态规划解决钢条切割问题 子问题图 重构解 钢条切割问题的简单Java实现 动态规划概述 和分治法一样, 动态规划 (dynamic programming)是通过组合子问题的解而解决整个问题的.分治法是将问题划分成一些独立的子问题,递归地求解各子问题,然后合并子问题的解而得到原问题的解.与此不同,动态规划适用于子问题并不独立的情况,即各子问题包含公共的子子问题.在这种情况下,分治法会重复地求解公共的子子问题.而动态

算法导论读书笔记(16)

算法导论读书笔记(16) 目录 动态顺序统计 检索具有给定排序的元素 确定一个元素的秩 区间树 步骤1:基础数据结构 步骤2:附加信息 步骤3:维护信息 步骤4:设计新操作 动态顺序统计 之前介绍过 顺序统计 的概念.在一个无序的集合中,任意的顺序统计量都可以在 O ( n )时间内找到.而这里我们将介绍如何在 O ( lg n )时间内确定任意的顺序统计量. 下图显示的是一种支持快速顺序统计量操作的数据结构.一棵 顺序统计树 T 通过在红黑树的每个结点中存入附加信息而成.在一个结点 x 内,增

算法导论读书笔记(14) - 二叉查找树的具体实现

算法导论读书笔记(14) - 二叉查找树的具体实现 目录 二叉查找树的简单Java实现 二叉查找树的简单Java实现 /** * 二叉查找树 * 部分代码参考自TreeMap的源码 */ public class BinarySearchTree<T> { protected TreeNode<T> root = null; private final Comparator<? super T> comparator; private int size = 0; pub

【算法导论学习笔记】第3章:函数的增长

????原创博客,转载请注明:http://www.cnblogs.com/wuwenyan/ ? 当算法的输入n非常大的时候,对于算法复杂度的分析就显得尤为重要,虽然有时我们能通过一定的方法得到较为精确的运行时间,但是很多时候,或者说绝大多数时候,我们并不值得去花精力求得多余的精度,因为精确运行时间中的倍增常量和低阶项已经被输入规模本身的影响所支配.我们需要关心的是输入规模无限增加,在极限中,运行时间是如何随着输入规模增大而增加的,通常来说,在极限情况下渐进地更优的算法在除很小的输入外的所有情