以有序链表构成的开放式散列表

最新推荐文章于 2022-10-09 20:43:56 发布
最新推荐文章于 2022-10-09 20:43:56 发布
阅读量929 收藏
点赞数
文章标签： 数据结构 delete null function unix 存储
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vector03/article/details/6277792
版权

1. 前言

在复杂编程中，常常遇到查找问题，如何能更快更简单的找到我们需要的数据是一个经典问题。在各种查找方法中最简单的是使用数组或者链表，进行线性查找，但是往往效率比较低。因为如果要查找的数据恰好在线性表前面那么自然很快就能得到结果，而目标处在最后则要耗费很多时间去挨个查找。另一方面，大量的线性查找也意味着我们的程序当中要嵌套大量的循环语句，这本身对于程序可读性和运行效率都是不利的。我个人不建议在程序中循环或者分支语句超过三层，多了就会让人感觉代码像一团浆糊，单单辨别划分程序块的括号就很困难了。

    为了能更快找到数据产生了很多更高级的数据结构，比如BST，跳跃表，散列表等等。这些数据结构都采用非线性方式查询数据，可以说各有优缺点。本文就是探讨如何使用开放式散列表来加速查找。

2. 原理分析

在各种查找问题中遇到最普遍的问题往往是这样的：给你一个键值(key)，在一堆的数据当中到底存不存在与其相关的记录，如果有的话记录的具体值是多少？我们可以想象，使用线性表的话，随着记录数目增多查找变得越发困难，散列表(Hash Table)也就应运而生。

散列表本身不像BST或者跳跃表那样属于有序结构。因此你的数据可以不必事先排序，散乱的堆放到表中。查找的核心在于散列函数(Hash Function)，通过将键值带入散列函数而计算得到一个索引值(Index)，这个索引值或者我们称之为槽号(Slot Number)就是数据记录的位置。因此理想的情况下我们根本不需要去轮询数据，只需要一次简单的计算就能得到数据的准确位置。

既然如此，整个算法的核心就在于这个散列函数。最简单的一个散列函数就是取模，也就是key % M。其中M代表散列表的大小，也就是槽的总数。不同的键值取得的模不同，数据也就通过运算被“分散”到一个线性空间里。到这里，你可能会发现并非所有的键值都会产生不同的散列值。比如，M为10的话，key如果为1，11，21都会取得余数为1，这样不同元素的散列就会发生碰撞，称之为散列冲突(Hash Collision)。那么，我们衡量一个好的散列函数就是通过尽可能少的计算，将键值更平均的分散到线性地址空间中，尽可能的减小冲突发生的可能性。显然，上面提到的这个例子并不是一个很好的解决方案。

这里有一个典型例子是UNIX系统中使用的著名的ELFHash函数，就是经典的字符串散列函数。该函数被用在UNIX的ELF文件系统中因此而得名。它能很好的实现任意长字符串的平均分布。

unsigned long Hashfn(char* pKey)

{

    unsigned long h = 0, g;

    while(*pKey)

    {

       h = (h << 4) + *pKey++;

       g = h & 0xF0000000L;

       if (g) h^= g >> 24;

       h &= ~g;

    }

    return h % M;

}

然而即便如此，在一个散列表中冲突发生还是不可避免的。我们几乎很难找到一个具有完美散列(Perfect Hashing)性质的函数。那么要想构建一个散列表就不得不考率冲突解决方案。由此，也引出了下面将要讨论的开放式散列表。

所谓的解决散列冲突就是将已经被占用的槽进行二次分配。一般的解决方案可以分为两类：一种是地址开放式的散列表，冲突的数据可以被放在表外，称为开散列(Open Hashing)。另外一种是将冲突数据按照一定的探查序列放在表内，为闭合散列。这里我选择开散列的原因在于其实现简单，而且更加灵活，利于内存操作。而闭合散列需要额外的探查函数(Probe Function)甚至二次散列函数进行二次探查，比较复杂。另外最重要的一点，闭合散列在进行删除操作时必须保留该槽曾经被占用的信息，有的书中将其形象称为“墓碑”，否则将会中断探查序列。然而长时间的增删操作之后，表内的墓碑就会越来越多，查询速度也就会越来越慢，为了提升效率只能重建探查序列甚至重建整个散列表，实在是麻烦。

3. 开放式散列

开放式散列实现的典型办法是在槽外挂接链表。建立时，键值被散列后查询该槽，如果发生冲突则在槽外挂接一个节点，由此实现了冲突解决。查询同理，发生冲突则根据后继指针遍历整个链表，非常方便。

由于开放式散列比闭合散列存在查询速度的劣势，为了提高查询效率，加入了自适应查询的功能。将链表改为双链表，并且在节点当中记录访问次数，每次访问后根据查询次数沿着前驱指针查找，将被访问最多的节点置换到更靠近槽的位置。换句话说，可以理解为根据槽内的访问次数实时排序。

4. 数据结构

目前的demo中将散列表封装成类CHashTable。为了节省内存空间，散列表内只记录节点指针，数据被加入表中时再动态申请空间。因此那些未被占用的槽就不会造成太严重的浪费。在CHashTable内部同样只记录了表指针，这样你可以根据自己的需要通过Create函数定制任意大小的散列表了。结构如下：

class CHashTable

{

protected:

    unsigned long m_nSize;

    PHASHTBLELEM* m_pHashTbl;

    void   ReSort(PHASHTBLELEM pElem);

    void   Remove(PHASHTBLELEM pElem);

public:

    CHashTable(void);

    ~CHashTable(void);

    void Create(unsigned long nHashMaxSize);

    unsigned long GetSize();

    unsigned long Hashfn(LPCTSTR pKey);

    void HashElem(LPWSTR pKey, LPVOID pData);

    BOOL UnHashElem(LPWSTR pKey);

    LPVOID FetchElem(LPWSTR pFetchKey);

};

 

链表节点被封装为结构体HASHTBLELEM，具体结构如下：

typedef struct _HASHTBLELEM

{

    LPWSTR pKey;

    LPVOID pData;

    UINT   nAccessCount;

    _HASHTBLELEM* pNextElem;

    _HASHTBLELEM* pPrevElem;

} HASHTBLELEM, *PHASHTBLELEM;

pKey中记录键值信息。pData被声明为无类型指针，你可以根据实际需要将任何东西放到节点当中，可以是一个变量，一个数组，一个结构体，甚至一个对象。这样做的好处在于给使用者更大的灵活性，缺点在于你必须自己手动强制转换成需要的类型，而且要特别小心接下来的指针操作，以免发生问题。在demo中我向pData中存放的是一个字符串。nAccessCount记录的是访问计数。最后两个成员是链表需要的前驱指针和后继指针。

5. 关于函数的说明

Create函数可以帮助你建立一个理想大小的散列表。

void CHashTable::Create(unsigned long nHashMaxSize)

{

    m_nSize = nHashMaxSize;

    m_pHashTbl = new PHASHTBLELEM[m_nSize];

    memset(m_pHashTbl, NULL,     sizeof(PHASHTBLELEM)*m_nSize);

}

 

HashElem可以向表内增加一个元素。当然你需要指定键值和要存储的数据。

void CHashTable::HashElem(LPWSTR pKey, LPVOID pData)

{

    UINT Index = Hashfn(pKey);

    PHASHTBLELEM* pSlot = &m_pHashTbl[Index];

    PHASHTBLELEM pElem = *pSlot;

    if (!pElem)

    {

       *pSlot = pElem = new HASHTBLELEM;

       pElem->pKey = pKey;

       pElem->pData = pData;

       pElem->nAccessCount = 0;

       pElem->pNextElem = NULL;

       pElem->pPrevElem = NULL;

    }

    else

    {

       while(pElem->pNextElem)

       {

           pElem = pElem->pNextElem;

       }

       pElem->pNextElem = new HASHTBLELEM;

       PHASHTBLELEM pPrevElem = pElem;

       pElem = pElem->pNextElem;

       pElem->pKey = pKey;

       pElem->pData = pData;

       pElem->nAccessCount = 0;

       pElem->pPrevElem = pPrevElem;

       pElem->pNextElem = NULL;

    }

}

 

 

 

 

UnHashElem是删除函数，可以删除相关键值的节点。如果成功返回TRUE，失败则返回FALSE。

BOOL CHashTable::UnHashElem(LPWSTR pKey)

{

    UINT Index = Hashfn(pKey);

    PHASHTBLELEM* pSlot = &m_pHashTbl[Index];

    PHASHTBLELEM pElem = *pSlot;

    if (pElem)

    {

       PHASHTBLELEM pNextElem = pElem->pNextElem;

       do

       {

           if (!StrCmp(pKey, pElem->pKey))

           {

              Remove(pElem);

              if (!pNextElem || !pNextElem->pPrevElem) *pSlot = pNextElem;

              return TRUE;

           }

           else

           {

               pElem = pElem->pNextElem;

           }

       } while (pElem);

    }

    return FALSE;

}

 

FetchElem是查询数据，只需要将键值带入就会返回相关数据的内容。需要注意的是返回值仍然是LPVOID注意类型转换。如果查询失败，函数会返回NULL。

LPVOID CHashTable::FetchElem(LPWSTR pFetchKey)

{

    unsigned long Index = Hashfn(pFetchKey);

    PHASHTBLELEM* pSlot = &m_pHashTbl[Index];

    PHASHTBLELEM pElem = *pSlot;

    if (pElem)

    {

       do

       {

           if (!StrCmp(pFetchKey, pElem->pKey))

           {

              pElem->nAccessCount++;

              ReSort(pElem);

              if (!pElem->pPrevElem) *pSlot = pElem;

              return pElem->pData;

           }

           else

           {

              pElem = pElem->pNextElem;

           }

       } while (pElem);

    }

    return NULL;

}

 

需要了解的一点是：这里UnHashElem和FetchElem分别调用了另外两个保护成员函数，Remove和Resort。前者的作用是删除并重新挂接节点，后者则是根据访问次数进行链表排序。代码如下：

void CHashTable::Remove(PHASHTBLELEM pElem)

{

    PHASHTBLELEM pPrevElem = pElem->pPrevElem;

    PHASHTBLELEM pNextElem = pElem->pNextElem;

    if (!pPrevElem)

    {

       delete[] pElem->pKey;

       delete[] pElem->pData;

       delete[] pElem;

       if (pNextElem) pNextElem->pPrevElem = NULL;

    }

    else

    {

       delete[] pElem->pKey;

       delete[] pElem->pData;

       delete[] pElem;

       pPrevElem->pNextElem = pNextElem;

       if (pNextElem) pNextElem->pPrevElem = pPrevElem;    

    }

}

 void CHashTable::ReSort(PHASHTBLELEM pElem)

{

if (pElem->pPrevElem && pElem->pPrevElem->nAccessCount < pElem->nAccessCount)

    {

       PHASHTBLELEM pPrevElem = pElem->pPrevElem;

       PHASHTBLELEM pPrevPrevElem = pPrevElem->pPrevElem;

       PHASHTBLELEM pNextElem = pElem->pNextElem;

       if (pPrevPrevElem) pPrevPrevElem->pNextElem = pElem;

       pElem->pPrevElem = pPrevPrevElem;

       pElem->pNextElem = pPrevElem;

       pPrevElem->pPrevElem = pElem;

       pPrevElem->pNextElem = pNextElem;

       if (pNextElem) pNextElem->pPrevElem = pPrevElem;

       ReSort(pElem);

    }

    else

    {

       return;

    }

}

 

 

 

6. 总结

关于开放式散列表我写了一个demo程序，可以作为参考。总的来说中心思想就是通过牺牲一点存储空间来大幅加快访问速度，而且不需要手动对内部元素做排序处理。

另外，还存在一种比较坏的访问情况，就是反复不断的交替访问某两个元素，而恰恰它们又都位于一个槽当中。这会导致链表当中的元素不断的互相挤占被访问的有利位置而造成程序效率下降。虽然可能不常见，但是想想任何数据结构都没有十全十美的解决方案吧。

 

 

附demo下载地址：http://download.csdn.net/source/3126408

vector03
关注
Algorithm：【算法进阶之路】之算法面试刷题集合—数据结构的简介、最强学习路线(逻辑结构【数组-链表-栈和队列/树-图-哈希】、物理结构【元素/关系】、数据运算【十大排序/四大查找-图三大搜索-
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
08-05 5941
​ Algorithm：【算法进阶之路】之算法面试刷题集合—数据结构的简介、最强学习路线(逻辑结构【数组-链表-栈和队列/树-图-哈希】、物理结构【元素/关系】、数据运算【十大排序/四大查找-图三大搜索-树三大遍历】、高级算法【枚举/回溯/递归/分治/动规/贪心】)、问题为导向的十大类刷题算法总结之详细攻略 目录 相关文章 数据结构思维导图 基本术语 一、数据结构的概述 二、数据的逻辑结构 三、数据的物理结构 四、数据的运算
数据结构知识点总结14-(第七章.查找)
最新发布
随风浪仔的专栏
03-01 524
数据结构知识点总结-(第七章.查找)。二分查找，二叉排序树，平衡二叉树，插入删除，分裂，B树，B+树，散列表，分块查找。
数据结构课程设计--线性开型寻址散列表
03-18
数据结构课程设计--线性开型寻址散列表，使用qt做的界面
开放地址散列表
yvhqbat的博客
12-02 621
开放地址散列表（open addressing hashing）：是一种不使用链表解决冲突的方法。如果有冲突发生，那么就要尝试选择另外的单元，直到找出空的单元为止。1.线性探测法 2.平方探测法 3.双散列//开放地址散列表 //类型声明 enum KindOfEntry{ legitimate, empty, deleted };struct HashEntry{
C++数据结构——散列表(开散列)
qq_45875966的博客
05-31 794
#include <iostream> #include <cmath> using namespace std; const int Maxsize=11; struct Node { int data; Node* next; }; class HashTable2 { public: HashTable2(); ~HashTable2(); int Insert(int k); Node* Search(int k); v
哈希表（开散列）
adorable_的博客
03-12 1042
开散列 开散列法又叫链地址法（开链法）。 开散列法：首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各桶中的元素通过一个单链表链接起来，个链表的头结点存储在哈希表中。
数据结构之哈希表二（用开散列法实现哈希表）
hj605635529的博客
04-25 1407
前面我们讲了哈希冲突的闭散列（开放定址法）的两种方法，现在我们来介绍另一种方法：开散列法。 通常，每个桶中的同义词子表都很短，设有n个关键码通过某一个散列函数，存放到散列表中的m个桶中，那么每一个桶中的同义词子表的平均长度为n/m。这样以搜索平均长度为n/m的同义词子表代替了搜索长度为n的顺序表，搜索效率快的多。 应用开散列法处理溢出，需要增设链接指针，似乎增加了存储开销。
散列表（hash）
qq_34420188的博客
03-06 701
散列方法不同于顺序查找、二分查找、二叉排序树及B-树上的查找。它不以关键字的比较为基本操作，采用直接寻址技术。在理想情况下，无须任何比较就可以找到待查关键字，查找的期望时间为O(1)。 散列表的概念 1、散列表      　设所有可能出现的关键字集合记为U(简称全集)。实际发生(即实际存储)的关键字集合记为K（|K|比|U|小得多）。      　散列方法是使用函数h将U映射到表T
散列表小总结
QuitePig的专栏
08-12 1059
一、散列函数 1、直接地址法 这类散列函数是一对一的映射，一般不会产生冲突，但是，它要求散列地址空间的大小与关键字集合的大小相同，这种要求是很苛刻的。特别是当关键字集合很大而且又不连续时，这种方法就不太适宜。 2、数字分析法 3、乘余取整法 4、除留余数法 二、 处理溢出的闭散列方法 1 线性探测法 2 二次探测法 3 双散列法 三、处理溢出的开散列方法- 1 链地址法
Java程序员必会之数据结构与算法全梳理
m0_71563599的博客
06-07 925
LinkedHashSet LinkedList 底层数据结构由链表和哈希表组成。 数据的添加和删除都较为方便，就是访问比较耗费时间。数组ArrayList 访问数据十分简单，而添加和删除数据比较耗工夫堆堆是一种图的树形结构，被用于实现“优先队列",优先队列是一种数据结构，可以自由添加数据，但取出数据时要从最小值开始按顺序取出堆的特点： ①堆中的每个结点最多有两个子结点②子结点必定大于父结点③把新数据放在最下面一行靠左的位置。当最下面一行里没有多余空间时，就再往下另起一行，把数据加在这一行的最左端④如果子结
检索（散列）
mumusan2016的博客
04-14 1362
检索算法分类： 顺序表和线性表法 根据关键码值直接访问方法（散列表） 树索引方法 顺序检索（关键码值按大小排序） 最基础的检索算法，但是遇到重复查找的庞大记录集合，顺序检索会慢到令人无法忍受。一般常用的索引方式是二分查找自组织线性表由于线性表大多数情况下是使用关键码进行顺序排序的，但是这对于一些特定情况将会减慢搜索速度，例如某一关键码时常出现，但是它又在线性表的末端，这样每次都得执行到末端才能访问
哈希表 - 闭散列
isjinhao的博客
09-05 657
闭散列主要就是需要注意一下“墓碑”的操作，其他的其实都简单。ASL的计算忘了，找了两道题都没算对，这才是我不写的真正原因…代码里是装13用的… #include&lt;bits/stdc++.h&gt; using namespace std; /* 哈希表： 散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也...
哈希 散列函数以及碰撞处理_散列| 公开地址以进行碰撞处理
06-28 703
哈希 散列函数以及碰撞处理Prerequisite: Hashing data structure 先决条件： 哈希数据结构 开放式寻址 (Open addressing) In open addressing, all the keys will be stored in the hash table itself, not by using any additional memory o...
关于HashMap的一些按位与计算的问题
蔡梦缘的博客
03-10 5382
关于HashMap的一些按位与计算的问题，HashMap.hash()
解决哈希冲突——闭散列和开散列（数据结构）
m0_51405559的博客
11-29 1357
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、闭散列二、开散列1.引入库2.读入数据三、再散列（了解） 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、闭散列 当发生哈希冲突时，从发生哈希冲突的位置开始按照某种方式找“下一个”空位置。 1.通过哈希函数计算哈希地址 2.插入元素----注意：可能
开放性地址处理法与冲突法处理哈希表的查找和插入
rzchong1988的专栏
08-21 1655
/*用开放性地址处理冲突法定义的哈希表*/ #define M 997 typedef struct{ KeyType key; DataType data; }NodeType; typedef NodeType HashTable[M]; --------------------------------------------------------------
C++之哈希表(开散列和闭散列)
weixin_56054625的博客
10-09 856
比如删除元素4，如果直接删除掉，44查找起来可能会受影响(因为如果删除4这个位置的值，查找44的时候会根据哈希函数先查找4这个位置，如果4为空了就不会再往后继续查找，所以44就不知道是否存在这个哈希表中，存在误判)。比如2.1中的场景，现在需要插入元素44，先通过哈希函数计算哈希地址，44%10=4，因此44理论上应该插在该4位置，但是该位置已经放了值为4的元素，即发生哈希冲突。对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功。
开放寻址法之线性探查——hash实现
weixin_33850890的博客
12-02 138
不怎么明白原理，参照一个网友的代码，自己写了一下，算是练手吧： #include &lt;iostream&gt; using namespace std; const int m = 19; int T[30]; void hasn_init() { for (int i = 0; i &lt; 30; ++i) { T[i] = -1; } } i...
Hash方法
一身清贫怎敢入繁华
10-19 593
> 1. 直接相加, 把(总和%大质数)为key. > 2. 平方和相加, 把(总和%大质数)为key. > 3. 从小到大的顺序, 对v[i]<<(i*3)依次异或, 然后模一个大质数作为key.(by hust07p43) > 4. 六个数中非零数的积再乘上一个大质数,然后模一个100w上下的数。 自己拿随机数据测下来110w左右的效果最好，随机情况...
散列表与链表结合使用的原因分析
散列表以其快速的查找、插入和删除操作（平均时间复杂度为O(1)）而受到青睐，而链表则允许动态调整元素顺序，尤其在需要频繁插入和删除元素时非常有用。当散列表与链表结合使用时，它们能够互补彼此的不足，从而在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值