第11章:散列表

原创 2016年05月30日 22:20:45

下面代码用分离链接法实现散列表:

1:将一个输入元素利用散列函数散列到某一个值:

int hash(int key)
{
        return key;
}
int hash(const string& key)
{
        int hashVal=0;
        for(string::size_type ix=0;ix!=key.size();ix++)
                hashVal=37*hashVal+key[ix];
        return hashVal;
}
template<class Type>
int HashTable<Type>::myHash(const Type& key) const
{
        int hashVal=hash(key);

        //vector<list<Type> > theLists
        hashVal%=theLists.size(); // 用到的是除法散列法,所以这个哈希表的size()为素数
        if(hashVal<0)
                hashVal+=theLists.size();
        return hashVal;
}

2:插入操作:
代码如下:

template<class Type>
bool HashTable<Type>::insert(const Type& val)
{
        list<Type>& whichList=theLists[myHash(val)];

        if(find(whichList.begin(),whichList.end(),val)!=whichList.end())
                return false;

        whichList.push_back(val);

        if(++currentSize>theLists.size())
                rehash(); // 装载因子超过了1,将其复制到另外一个
       size()更大的哈希表中,rehash()函数下面会给出

        return true;
}

3:查找某一个元素是否已经包含在该哈希表中:

template<class Type>
bool HashTable<Type>::contains(const Type& val) const
{
        const list<Type>& whichList=theLists[myHash(val)];
//      if(find(whichList.begin(),whichList.end(),val)!=whichList.end())
//              return true;
//      return false;
        return find(whichList.begin(),whichList.end(),val)!=whichList.end();
}

4:删除操作

template<class Type>
bool HashTable<Type>::remove(const Type& val)
{
        list<Type>& whichList=theLists[myHash(val)];

        typename list<Type>::iterator it=find(whichList.begin(),whichList.end(),val);
        if(it==whichList.end())
                return false;

        whichList.erase(it);
        --currentSize;
        return true;
}

5:如果该哈希表中装载因子达到某一个值后,就不能再插入元素了,如果还要再插入元素,就将其散列到另外一个哈希表中

template<class Type>
void HashTable<Type>::rehash()
{
        vector<list<Type> > oldLists=theLists;
        theLists.resize(nextPrime(2*theLists.size()));

        for(typename vector<list<Type> >::size_type ix=0;ix!=theLists.size();ix++)
                theLists[ix].clear();
        currentSize=0;

        for(typename vector<list<Type> >::size_type ix=0;ix!=oldLists.size();ix++)
                for(typename list<Type>::const_iterator it=oldLists[ix].begin();it!=oldLists[ix].end();it++)
                        insert(*it);
}
版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

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

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

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

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

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

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

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

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

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

前一节介绍是最简单的冲突解决方法-链接法。开放寻址与链接法不同,所有元素都放在散列表内。 在这种方法中,散列表可能会被填满。开放寻址不需要指针,只需要计算出要存取的各个槽。 由于不用存储指针而节省...
  • dc_726
  • dc_726
  • 2012-03-12 21:34
  • 2215

《算法导论》第11章 散列表 个人笔记

第11章 散列表 11.1 直接寻址表 11.2 散列表 11.3 散列函数 11.4 冲突

算法导论-第11章-散列表

转自:http://blog.csdn.net/mishifangxiangdefeng/article/details/7713307 一、概念 1.综述 散表表仅支持INSERT、SEA...

算法导论-第11章-散列表

一、概念 1.综述 散表表仅支持INSERT、SEARCH、DELETE操作。 把关键字k映射到槽h(k)上的过程称为散列。 多个关键字映射到同一个数组下标位置称为碰撞。 好的散列函数应使每个关键字都...

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

转载:http://www.cnblogs.com/Anker/archive/2013/01/27/2879150.html

算法导论 第11章 散列表

散列表是主要支持动态集合的插入、搜索和删除等操作,其查找元素的时间在最坏情况下是O(n),但是在是实际情况中,散列表查找的期望是时间是O(1),散列表是普通数组的推广,因为可以通过元素的关键字在数组对...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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