《算法导论》读书笔记之第11章 散列表
2013-01-27 22:24
267 查看
摘要:
本章介绍了散列表(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),用除余法构造散列函数,初始情况如下图所示:
View Code
程序测试结果如下所示:
![](http://images.cnitblog.com/blog/305504/201301/28142404-bd80767dbd744038a025b8360781d654.png)
参考:/article/5165992.html
本章介绍了散列表(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),用除余法构造散列函数,初始情况如下图所示:
View Code
#include <iostream> #include <vector> #include <list> #include <string> #include <cstdlib> #include <cmath> #include <algorithm> using namespace std; int nextPrime(const int n); template <class T> class HashTable { public: HashTable(int size = 101); int insert(const T& x); int remove(const T& x); int contains(const T& x); void make_empty(); void display()const; private: vector<list<T> > lists; int currentSize; int hash(const string& key); int myhash(const T& x); void rehash(); }; template <class T> HashTable<T>::HashTable(int size) { lists = vector<list<T> >(size); currentSize = 0; } template <class T> int HashTable<T>::hash(const string& key) { int hashVal = 0; int tableSize = lists.size(); for(int i=0;i<key.length();i++) hashVal = 37*hashVal+key[i]; hashVal %= tableSize; if(hashVal < 0) hashVal += tableSize; return hashVal; } template <class T> int HashTable<T>:: myhash(const T& x) { string key = x.getName(); return hash(key); } template <class T> int HashTable<T>::insert(const T& x) { list<T> &whichlist = lists[myhash(x)]; if(find(whichlist.begin(),whichlist.end(),x) != whichlist.end()) return 0; whichlist.push_back(x); currentSize = currentSize + 1; if(currentSize > lists.size()) rehash(); return 1; } template <class T> int HashTable<T>::remove(const T& x) { typename std::list<T>::iterator iter; list<T> &whichlist = lists[myhash(x)]; iter = find(whichlist.begin(),whichlist.end(),x); if( iter != whichlist.end()) { whichlist.erase(iter); currentSize--; return 1; } return 0; } template <class T> int HashTable<T>::contains(const T& x) { list<T> whichlist; typename std::list<T>::iterator iter; whichlist = lists[myhash(x)]; iter = find(whichlist.begin(),whichlist.end(),x); if( iter != whichlist.end()) return 1; return 0; } template <class T> void HashTable<T>::make_empty() { for(int i=0;i<lists.size();i++) lists[i].clear(); currentSize = 0; return 0; } template <class T> void HashTable<T>::rehash() { vector<list<T> > oldLists = lists; lists.resize(nextPrime(2*lists.size())); for(int i=0;i<lists.size();i++) lists[i].clear(); currentSize = 0; for(int i=0;i<oldLists.size();i++) { typename std::list<T>::iterator iter = oldLists[i].begin(); while(iter != oldLists[i].end()) insert(*iter++); } } template <class T> void HashTable<T>::display()const { for(int i=0;i<lists.size();i++) { cout<<i<<": "; typename std::list<T>::const_iterator iter = lists[i].begin(); while(iter != lists[i].end()) { cout<<*iter<<" "; ++iter; } cout<<endl; } } int nextPrime(const int n) { int ret,i; ret = n; while(1) { int flag = 1; for(i=2;i<sqrt(ret);i++) if(ret % i == 0) { flag = 0; break; } if(flag == 1) break; else { ret = ret +1; continue; } } return ret; } class Employee { public: Employee(){} Employee(const string n,int s=0):name(n),salary(s){ } const string & getName()const { return name; } bool operator == (const Employee &rhs) const { return getName() == rhs.getName(); } bool operator != (const Employee &rhs) const { return !(*this == rhs); } friend ostream& operator <<(ostream& out,const Employee& e) { out<<"("<<e.name<<","<<e.salary<<") "; return out; } private: string name; int salary; }; int main() { Employee e1("Tom",6000); Employee e2("Anker",7000); Employee e3("Jermey",8000); Employee e4("Lucy",7500); HashTable<Employee> emp_table(13); emp_table.insert(e1); emp_table.insert(e2); emp_table.insert(e3); emp_table.insert(e4); cout<<"Hash table is: "<<endl; emp_table.display(); if(emp_table.contains(e4) == 1) cout<<"Tom is exist in hash table"<<endl; if(emp_table.remove(e1) == 1) cout<<"Removing Tom form the hash table successfully"<<endl; if(emp_table.contains(e1) == 1) cout<<"Tom is exist in hash table"<<endl; else cout<<"Tom is not exist in hash table"<<endl; //emp_table.display(); exit(0); }
程序测试结果如下所示:
![](http://images.cnitblog.com/blog/305504/201301/28142404-bd80767dbd744038a025b8360781d654.png)
参考:/article/5165992.html
相关文章推荐
- 《算法导论》读书笔记之第11章 散列表
- 《算法导论》读书笔记之第11章 散列表
- 《算法导论》第11章 散列表 (2)散列表
- 《算法导论》第11章 散列表 (3)开放寻址
- 《算法导论》笔记 第11章 11.2 散列表
- 《算法导论》第11章 散列表 (3)开放寻址
- 算法导论-第11章-散列表
- 《算法导论》笔记 第11章 11.2 散列表
- 《算法导论》第11章 散列表 (1)直接寻址表
- 《算法导论》第11章 散列表 (3)开放寻址
- 算法导论学习笔记——第11章 散列表
- 《算法导论》学习总结 — 10. 第10章(略) && 第11章 散列表
- 《算法导论》第11章 散列表 (1)直接寻址表
- 《算法导论》第11章 散列表 (3)开放寻址
- 《算法导论》第11章 散列表 (1)直接寻址表
- 《算法导论》第11章 散列表 (1)直接寻址表
- 算法导论第11章 散列表(哈希表)
- 算法导论-第11章-散列表
- 算法导论 第11章 散列表
- 算法导论代码 第11章 散列表