CN106326475A - 一种高效的静态哈希表实现方法及系统 - Google Patents

Abstract

本发明涉及一种高效的静态哈希表实现方法及系统。该方法包括以下步骤：1)设定哈希桶大小hash_bit，生成多个数据对，将key[i]和value[i]对应于关键字和值；2)根据key[i]值，利用rank操作构建哈希表，并计算C表和D表；3)根据C表和D表计算rank(h)，并根据rank(h)的值存储相应的key[i]和value[i]；4)根据所要查询的值key判断哈希表中是否存在该元素，若存在则在对应存储位置查询并返回value值，否则访问失败；5)根据步骤4)所得的结果返回结果信息。本发明利用Rank‑select算法实现新型静态哈希表的构建与访问，可用于内容过滤、信息安全等领域。

Description

一种高效的静态哈希表实现方法及系统

技术领域

本发明旨在设计静态哈希表压缩算法，用于内容过滤、信息安全等领域。由于静态哈希表的存储占用空间较大，现今的算法对于静态哈希表的压缩还有很大优化空间。本发明旨在对静态哈希表进行压缩，可支持对静态哈希表的访问。

背景技术

数据结构中的查找表分为静态查找表和动态查找表。查找表主要针对表中的数据不断地查找，直到找出其所需要的值为止。静态查找表的类型主要包括顺序查找、二分查找、分块查找及静态树表的查找等，而动态查找表的类型主要包括二叉排序树、平衡二叉树、B树和B+树等。上述介绍的查找算法查找的效率取决于比较次数，查找平均次数越多，其效率越低，平均而言查找表的查找效率并不高。为了快速定位数据，可以使用哈希表来提升访问效率。

哈希表又叫做散列表，它利用键值对(key-value)来存储数据，是一种特殊的数据结构。哈希表通过把键值对映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做哈希函数，存放记录的数组叫做哈希表。哈希表中的映射不一定是单射，故可能会产生哈希冲突的现象，数据结构中有很多算法可以解决哈希冲突。哈希表的应用场景十分广泛，应用哈希表存储数据来实现快速查找是很常见的操作。在实际的计算科学中，哈希表可以在对等网络(P2P)中的路由选择、数据库查找、压缩序数索引和信息安全等方面发挥着巨大的应用。

在实际生活中，哈希表也有着重要的作用。比如，银行要进行前台数据和后台数据进行对账处理时，可以根据键查找到相应的值，从而完成前后台数据的对账工作；生活中利用的IC卡乘坐公交时，将IC卡的编号作为键，上车刷卡记录为哈希表的插入过程，值中存储上车时间和站名，下车刷卡记录为哈希表的查找过程，同时删除哈希表中此编号信息并计算时间和间距。

哈希表按照是否支持动态增删操作，分为静态哈希表和动态哈希表。静态哈希表是对于HASH操作只支持查询操作，不支持动态增删操作。静态哈希表适用于一次将数据预存至哈希表中，之后的工作主要负责快速查找数据。在模式串匹配算法中，静态哈希表很符合某些算法的应用背景，例如Wu-Manber、Karp-Rabin等高效算法都是利用HASH函数对规则进行处理来匹配文本，这些哈希操作往往是预先将规则一次加载至哈希表中，然后再进行匹配。

现今的哈希表算法主要包括线性探测哈希算法、二分查找算法和二分哈希算法。这些算法也满足静态哈希表的需求，在存储和查询时可以有效地定位数据，但是其空间存储与查询效率方面还有很大提升空间。下面简要介绍各算法的思想。

线性探测算法：当关键字key的通过哈希函数H(key)得到的哈希地址p冲突时，以p为标准，通过哈希函数H(key)另外得到新的哈希地址p1，……，如此进行迭代计算，当终于有一个哈希地址pi不出现冲突时为止，并将所对应的关键字和值存到该哈希地址上。查找时，先通过哈希函数H(key)，找出哈希桶中是否存在关键字key，若存在，返回value值。

二分查找算法：存储时，对关键字key值排序；查找时，利用二分算法查找key值，进而查出value。

二分哈希算法：链地址分为不同的哈希桶，存储时，每个桶内利用二分查找算法存储。查找时，先通过哈希函数判断所在哈希桶，在哈希桶内利用二分查找算法查找key值，进而查出value。

上述哈希表的算法在实际中均有广泛的应用，其存储和查询效率各有差异，存储所占空间和查询效率方面各有千秋。为了设计更加高效的哈希表算法，更加节省哈希表所占用的空间，本发明将利用rank-select算法对静态哈希表进行压缩，该算法在空间和时间方面与其他算法相比都有很大的提升。Rank-select算法是1989年文献“JacobsonG.Space-efficient static trees and graphs[C]//Foundations of ComputerScience,1989.,30th Annual Symposium on.IEEE,1989:549-554.”中用位向量存储树结构所提出的一种压缩空间的算法。下面将详细介绍rank-select算法。Rank-select算法在文献中主要是为了压缩邻接树结构，如图1所示，将原来的基于指针存储的树结构简化为利用二进制串进行存储，其主要思想就是利用了rank-select算法。

为介绍rank-select算法，首先定义参数rank(m):在二进制字符串中从第一个位置开始到位置m处1的个数。如图2中rank(10)＝7。

图3中，二叉树从根节点按照二叉树高度大小依次标注节点，其中黑色表示节点存在，白色表示节点为空，按照树的层级结构进行层级存储，可以看到共有8个节点为1，代表原矩阵中的8个节点信息。由图中可以看出，原二叉树结构的存储1个节点利用n个字节存储，如果按照位进行存储，其空间占用上会大大减少。

在文献“V,Navarro G.Rank and select revisited and extended[J].Theoretical Computer Science,2007,387(3):332-347.”中证明对于大小为n的位向量B，仅需要o(n)的额外存储空间，即可实现O(1)时间复杂度的Rank操作。SSE指令级含有_mm_popcnt_u64等指令支持64位以上的rank位操作，在硬件上实现了rank操作，使得操作更加快捷。此外，Rank-select算法在压缩稀疏矩阵方面能取得惊人的效果。

Rank-select算法能有效压缩数据，可以转化为哈希表的存储结构，为简述O(1)复杂度的rank操作，现介绍一个例子说明其算法思想。如图4所示，对于大小为n*8位的位向量B，D表和C表分别存储长度为8和32的rank操作，即存储到目前位置为止，前面1的个数。例如查询B[6]中第1个位置h的1的个数，则rank(h)＝C[1]+D[1*4+2]+_mm_popcnt_u64(B[6]>>7)＝6+4+1＝11。其中“_mm_popcnt_u64”表示SSE4.2指令集的一条内部指令，表示当前位置到初始位置1的个数。

接下来介绍O(1)时间复杂度的Rank操作具体实现过程，如图5所示。图中是例子中Rank操作的一般拓展：哈希表共存储n个key-value对，对于每个D向量，存储长度为s位，所用位数占log₂r，每个C向量，存储长度为r位，所占位数是log₂n，所以D向量共占比特，C向量共占比特，故额外空间共有

$M=\frac{n}{s}{\log }_{2}r+\frac{n}{r}{\log }_{2}n---\left(3\right)$

当计算第m个位置的rank值时，其中m＝i*r+j*s+k,其中0≤k＜s，可以利用以下公式进行计算：

$C\[i\]=\underset{k=0}{\overset{ir-1}{\Σ}}B\[k\]---\left(4\right)$

$D\[i,j\]=\underset{k=ir}{\overset{ir+js-1}{\Σ}}B\[k\]---\left(5\right)$

rank(B,m)＝C[i]+D[i,j]+rank(B_i*r+j*s,k) (6)

其中，rank(B_i*r+j*s,k)表示从第i*j+j*s个位置到第m个位置为止，1的个数，示意图为图6。

综上所述，Rank-select算法可以很好地实践在压缩邻接表结构上，能有效压缩空间。在静态哈希表中也需要进一步优化空间效率，故本发明旨在利用Rank-select算法实现新型静态哈希表的构建与访问。

发明内容

本发明提供一种高效的静态哈希表实现方法及系统，能够利用Rank-select算法实现新型静态哈希表的构建与访问。

本发明可以将静态哈希表进行有效的压缩，并且可以实现直接访问。图7是传统哈希表的存储方式，H代表哈希桶的大小，n代表关键字个数。按照指针占4个字节，整型占用4个字节的空间，所占空间共有4H+8n字节。

前述内容介绍了O(1)复杂度的rank操作的具体过程，为了便于计算机实现，本发明结合计算机的存储结构，设计了一种O(1)复杂度的rank操作具体实现方式，这也是设计基于Rank操作的哈希表压缩方案中的基本思想。实验中取r＝256，s＝64，C[i]用一个int表示，D[i]用一个char表示，则额外占用的空间是：

$M=\frac{n}{s}{\log }_{2}r+\frac{n}{r}{\log }_{2}n=\frac{n}{s}*8+\frac{n}{r}*32=\frac{n}{64}*8+\frac{n}{256}*32=\frac{n}{4}$

基于Rank操作的哈希压缩算法则将原来的指针换为是一个二进制向量B，首先需要设置哈希表的大小hash_bits，关键字key存储时，需要先做模运算h＝key mod(hash_bits)。通过计算rank(h)的值，从而不断将其映射到存储单元，如图8所示。由前述可知，需要浪费额外空间是比特(H为哈希桶的大小)，所以总共的存储空间为字节，空间比原来大大减少。

为方便静态哈希表的存储，建立以下的结构体以供后续使用：

CB

{

C

D

bitmap[4]

}

每一个CB是一个结构体，表示哈希表结构，包含三个变量。C表表示存储固定长度r的rank操作，D表表示存储固定长度s的rank操作，C表为整型，D表为char型(D表和C表也可设置为其他类型，只要能将固定长度r或s位rank操作的位数存储上即可)。为方便计算机存储，设置r＝256，s＝64。bitmap是一个大小为4的无符号的长整型数组，bitmap[i](i＝0，1，2，3)表示bitmap的某个元素。由于每一个无符号的长整型占用64位大小，所以，一个bitmap数组占用256位，正好是本文中C表存储的rank操作的长度，而每一个bitmap的元素值正好是D表存储的rank操作的长度。

建立哈希表CB数组，假设哈希表某个元素CB[j]，则该元素结构体中的值可以表示为CB[j].C，CB[j].D，CB[j].bitmap[i](i＝0，1，2，3)。为了便于描述C表和D表，下面的CB[j].C和C[j]表示同等含义，CB[j].D和D[j]表示同等含义。

为详细描述本发明的内容，本节先介绍构建哈希表及其访问系统的几大部件和流程过程，随后介绍具体的构建哈希表和访问哈希表的主要过程。

本发明中，构建哈希表及其访问系统主要包含以下部件，如图9所示：

1)系统预处理部件：设定哈希桶大小hash_bit，生成多个数据对，key[i]和value[i]相对应于关键字和值。

2)构建哈希表部件：根据key[i]值，利用rank操作构建哈希表，并计算C表和D表。

3)存储信息部件：根据C表和D表，计算rank(h)，其中h＝key mod(hash_bits)，并根据rank(h)的值存储相应的key[i]和value[i]。

4)访问信息部件：根据所要查询的的值key，判断哈希表中是否存在该元素，若存在，则在对应存储位置查询并返回value值，否则，访问失败。

5)返回信息部件：根据上一步所得的结果，返回结果信息。

以上介绍了构建哈希表及其访问系统的各部件，为了便于理解其构建和访问的过程，方便计算机存储，其rank操作的计算过程可以用以下的伪代码表示：

上述rank操作的计算过程用自然语言描述如下：

1)查询变量B中第i位前共有多少个1，首先将下标i与63做与运算的值赋值给k，再将下标i右移8位的值赋值给i₁，再将下标i右移6位并减去i₁左移2位的值赋值给i₂，则i₁为C表对应的下标，下标i右移6是D表对应的下标。

2)将变量B中从下标为(i₁<<8+i₂<<6)开始，(i₁<<8+i₂<<6+k-1)结束的这段变量赋值到e中。

3)最终返回值为C[i1]、D[i>>6]与_mm_popcnt_u64(e)的总和，即为变量B中第i位前1的个数，也是变量B的rank(i)操作。

rank操作的计算过程在哈希表的构建和访问中都会频繁用到，针对前文中对C表和D表中的具体实现，以下介绍的哈希桶的大小不少于2⁸，均利用上面的rank操作来存储和访问数据。本发明分为构建哈希表和查询关键字两个过程，所以针对这两个过程简述其基于rank操作的哈希表存储和访问的具体步骤。

1.基于rank操作的哈希表存储算法的具体步骤：

1)将预处理的数据分为key和value数组，key[i]、value[i]与关键字、键值相对应。

2)预先一次性导入key值至bitmap中。设key-value对共有num个元素，则CB表的大小为先定义哈希桶的数量为hash_bit，hash_bit值为CB表的大小clength和2⁸的乘积。对每个哈希桶内分配4个大小的bitmap(即含有4个元素的bitmap)，每个bitmap元素存储64位的数据，初始化设置为各位均为0，如图10所示。按照时间度O(1)的rank操作进行记录key数组的数据内容。先对key与hash_bit取模得到h，确保落在哈希桶内；然后将h存储在哈希桶对应位置上，按照如下公式记录h的位置，直到所有的key值均依次记录位置。

q＝h&255

CB[h>>8].bitmap[q>>6]|＝(1<<(q&63)) (7)

3)存储计算C数组和D数组。由于第二步相当于按照h值的大小，记录所有key值的相应位置信息，所以可利用前述的rank操作从哈希表CB[0]开始记录C数组和D数组的相应信息，其中C[i]表示前面CB[i-1]个哈希桶内1的个数，CB[i].D[1]表示CB[i].bitmap[0]中1的个数，……CB[i].D[3]表示CB[i].bitmap[0]到CB[i].bitmap[2]中1的个数。

4)利用C表和D表信息，利用前文中的rank操作的算法计算每个key值对应的rank值。

5)利用rank值记录每个哈希桶内元素个数，按照哈希表C的顺序叠加记录。利用rank值作为顺序存储key、value值。若不同的key有同一rank值，即落在同一个哈希桶内出现了哈希冲突。现在的rank值有了第二层意义，即对于h＝key mod(hash_bit)进行了排序，利用rank值代表排序的位置，那么进行存储key-value对的时候，其rank值相同时，说明其哈希桶内存在2个以上的元素，为了便于存储，首要顺序按照rank值大小顺序存储，次要顺序按照rank值相同依次存储。

6)存储key、value值到数组中。

2.基于rank操作的哈希表访问算法的具体步骤：

1)先对要查询的数据key与hash_bit取模得到h。

2)计算q＝h&255，判断CB[h>>8].bitmap[q>>6]和(1<<(q&63))做与运算是否为1，即在原来哈希桶内是否有key值。若此步判断为0，则原哈希表内没有该key值，查询失败；若此步判断为1，则原哈希表内有该key值，则需要找到value值。

3)为了防止哈希冲突，即原哈希表内该位置有两个及以上的关键字值命中，则在该哈希桶内依次判断是否含有查询数据key，若包含，返回value值，若不包含，查询下一个关键字，直至关键字为空，查询失败。

本发明的有益效果如下：

本发明利用Rank-select算法实现新型静态哈希表的构建与访问，能够对静态哈希表进行压缩，可支持对静态哈希表的访问，能够进一步优化空间效率；该方案可用于内容过滤、信息安全等领域。

附图说明

图1是二进制串进行存储邻接树结构示意图。

图2是rank操作示例图。

图3是利用rank-select算法对二叉树节点进行存储示例图。

图4是O(1)时间复杂度的Rank操作示例图。

图5是O(1)时间复杂度的Rank操作实现图。

图6是计算第m个位置的rank操作示意图。

图7是传统哈希表的存储方式示意图。

图8是基于Rank操作的紧凑哈希表存储方式示意图。

图9是基于rank操作静态哈希表构建及访问的系统部件图。

图10是哈希表存储结构示意图。

图11是哈希桶示例展示图。

具体实施方式

下面通过具体实施例对本发明做进一步说明。

本节主要针对发明内容中的具体步骤来介绍，针对所要存储的具体数据来分析，分为基于rank操作的哈希表存储过程和基于rank操作的哈希表访问过程。

1.基于rank操作的哈希表存储过程示例：

下面举例说明前述存储步骤。假设哈希桶的大小hash_bit＝2⁹，要存储的数据见下表1，那么相应的h值也见下表所示。

表1哈希表存储数据key、value及h值

key	1	513	65	257
					value	1	2	3	4
h	1	1	65	257

key取模后的数据按照二进制表示如图11左上显示，所以对应的哈希表如图11下方所示，所以，C[0]＝0,C[1]＝2,C[2]＝3；CB[0].D[0]＝0，CB[0].D[1]＝1，CB[0].D[2]＝2，CB[0].D[3]＝2，CB[1].D[0]＝0，CB[1].D[1]＝1，CB[1].D[2]＝1，CB[1].D[3]＝1；存储key,value值至二维数组中，按照rank(h)值排序可知，rank(h)＝1时有两个key映射到同一位置，见表2，则存储时，坐标变化见表3，其中idx是累加前几项所得到的，代表其存储终结key坐标的一半减去1，则存储key、value的一维数组见表4，其中，idx1表示数组的坐标编号，key的坐标为偶数，value坐标为奇数。

表2 rank(h)值及其数目

rank(h)	1	2	3
				count	2	1	1

表3累加数目得到坐标idx

rank(h)	1	2	3
				idx	2	3	4

表4一维数组idx1存储key、value值

idx1	0	1	2	3	4	5	6	7
									key or value	1	1	513	2	65	3	257	4

2.基于rank操作的哈希表查询过程示例：

哈希表建立过程依照存储例子所示，假使要查询key＝513是否在哈希表中，首先计算h＝1q＝1,CB[h>>8].bitmap[q>>6]＝1成立，由于该位置有两个key值命中，则查找idx1[0]和idx1[2]是否与513相等，由于idx1[2]＝513，则返回value＝idx1[3]＝2，查询成功。

基于上述方案设计，下面将基于Rank操作的哈希表压缩算法与二分查找算法、线性探测哈希算法和二分哈希算法进行比较，其中测试数据是1000万个key-value对，key和value为随机生成的32位无符号整数，共占用76.294MB存储空间。待查询数据是1000万个随机生成的32位无符号整数，设置查询命中率为1％。实验测试环境是64位WIN7操作系统，Intel CPU i5，4GB内存。

由于哈希表桶大小这一参数可以进行调节，所以实验中针对不同的算法，哈希表桶大小也做了不同的测试。基于Rank操作的哈希表压缩算法可以利用SSE指令集中_mm_popcnt_u64等指令支持64以上的rank位操作，该实验测试中使用SSE指令集与不使用的SSE指令集的算法都做了相对应的比较。

实验一：使用SSE指令集与不使用SSE指令集的基于Rank操作的哈希表压缩算法

如表5和6所示，两种算法的额外空间都随着哈希表桶的增大而增大，查询速度在哈希表桶为2²⁹时速度最大。使用SSE指令集比不使用SSE指令集的基于Rank操作的哈希表压缩算法在相同大小哈希表桶的情况下，查询速度明显占优势。这说明在硬件中实现的rank位操作要优于软件设计的rank位操作。

表5基于Rank操作的哈希表压缩算法(Rank for SSE)

哈希表桶大小	Key-value空间(MB)	额外空间(MB)	查询速度(万次/秒)
				224	76.294	31.265	1779
225	76.294	38.023	2463
				226	76.294	45.478	2906
227	76.294	56.802	3278
				228	76.294	77.490	4000
229	76.294	117.838	4566
				230	76.294	198.014	4000

表6基于Rank操作的哈希表压缩算法(Rank None SSE)

哈希表桶大小	Key-value空间(MB)	额外空间(MB)	查询速度(万次/秒)
				224	76.294	31.265	744
225	76.294	38.023	1303
				226	76.294	45.478	2000
227	76.294	56.802	2785
				228	76.294	77.490	3367
229	76.294	117.838	4255
				230	76.294	198.014	3773

实验二：二分查找算法、哈希二分查找算法和线性探测哈希算法

表7二分查找算法(CBinarySearch)

Key-value空间(MB)	额外空间(MB)	查询速度(万次/秒)
			76.294	0	172

表8哈希二分查找算法(CHashBinarySearch)

哈希表桶大小	Key-value空间(MB)	额外空间(MB)	查询速度(万次/秒)
				224	76.294	64	1600
225	76.294	128	1776
				226	76.294	256	1883
227	76.294	512	1560

表9线性探测哈希算法(CLinearProbe)

通过以上3个实验，可以看出：1：二分查找算法不需要额外空间和哈希桶大小参数，但是查询速度比较慢。2：线性探测算法在哈希桶大小2²⁶为时，能达到3558万次/秒的查询速度，效率在三种算法中最优，但是额外空间占用较大，达到435.706MB。3：哈希二分查找算法中在哈希桶大小2²⁶为时，能达到1883万次/秒的查询速度，速度劣于线性探测算法，但是额外空间较小，为256MB。

实验三：基于Rank操作压缩哈希表的压缩算法与实验二中算法对比

表10五种哈希压缩算法实验对比表

通过以上实验对比，可以看出：基于Rank操作的哈希表压缩算法在查询速度和占用空间方面都有很大优势，其速度和额外空间都远远超过其他三种算法。使用SSE指令集时，基于Rank操作的哈希表压缩算法在哈希桶大小2²⁹为时，能达到4566万次/秒的查询速度，额外空间仅占用117.838MB。

以上实施例仅用以说明本发明的技术方案而非对其进行限制，本领域的普通技术人员可以对本发明的技术方案进行修改或者等同替换，而不脱离本发明的精神和范围，本发明的保护范围应以权利要求书所述为准。

Claims (9)

1.一种高效的静态哈希表实现方法，其特征在于，包括以下步骤：

1)设定哈希桶大小hash_bit，生成多个数据对，将key[i]和value[i]对应于关键字和值；

2)根据key[i]值，利用rank操作构建哈希表，并计算C表和D表，其中C表表示存储固定长度r的rank操作，D表表示存储固定长度s的rank操作；

3)根据C表和D表计算rank(h)，其中h＝key mod(hash_bits)，并根据rank(h)的值存储相应的key[i]和value[i]；

4)根据所要查询的值key判断哈希表中是否存在该元素，若存在则在对应存储位置查询并返回value值，否则访问失败；

5)根据步骤4)所得的结果，返回结果信息。

2.如权利要求1所述的方法，其特征在于，步骤3)采用以下步骤实现基于rank操作的哈希表存储过程：

3-1)将预处理的数据分为key和value数组，key[i]、value[i]与关键字、键值相对应；

3-2)预先一次性导入key值至bitmap中，定义哈希桶的数量为hash_bit，按照时间度O(1)的rank操作记录key数组的数据内容；对key与hash_bit取模得到h，确保落在哈希桶内，然后将h存储在哈希桶对应位置上，按照h值的大小，记录所有key值的相应位置信息；

3-3)存储计算C数组和D数组，利用rank操作从哈希表CB[0]开始记录C数组和D数组的相应信息；

3-4)利用C表和D表信息，计算每个key值对应的rank值；

3-5)利用rank值记录每个哈希桶内元素个数，按照哈希表C的顺序叠加记录，利用rank值作为顺序存储key、value值；

3-6)存储key、value值到数组中。

3.如权利要求2所述的方法，其特征在于，步骤3-2)中，hash_bit的值为CB表的大小clength和2⁸的乘积，对每个哈希桶内分配4个大小的bitmap，每个bitmap存储64位的数据，初始化设置为各位均为0。

4.如权利要求3所述的方法，其特征在于，步骤3-2)按照如下公式记录h的位置，直到所有的key值均依次记录位置：

q＝h&255，

CB[h>>8].bitmap[q>>6]|＝(1<<(q&63))。

5.如权利要求2所述的方法，其特征在于，步骤3-5)中，在存储key-value对时，若不同的key有同一rank值，则首要顺序按照rank值大小顺序存储，次要顺序按照rank值相同依次存储。

6.如权利要求1所述的方法，其特征在于，步骤4)采用以下步骤实现基于rank操作的哈希表访问过程：

4-1)对要查询的数据key与hash_bit取模得到h；

4-2)计算q＝h&255，判断CB[h>>8].bitmap[q>>6]和(1<<(q&63))做与运算是否为1，即在原来哈希桶内是否有key值；若此步判断为0，则原哈希表内没有该key值，查询失败；

若此步判断为1，则原哈希表内有该key值，则需要找到value值；

4-3)为了防止哈希冲突，即原哈希表内该位置有两个及以上的关键字值命中，则在该哈希桶内依次判断是否含有查询数据key，若包含，返回value值，若不包含，查询下一个关键字，直至关键字为空，查询失败。

7.一种高效的静态哈希表实现系统，其特征在于，包括：

系统预处理部件，用于设定哈希桶大小hash_bit，在生成多个数据对，将key[i]和value[i]对应于关键字和值；

构建哈希表部件，用于根据key[i]值，利用rank操作构建哈希表，并计算C表和D表，其中C表表示存储固定长度r的rank操作，D表表示存储固定长度s的rank操作；

存储信息部件，用于根据C表和D表计算rank(h)，其中h＝key mod(hash_bits)，并根据rank(h)的值存储相应的key[i]和value[i]；

访问信息部件，用于根据所要查询的值key判断哈希表中是否存在该元素，若存在则在对应存储位置查询并返回value值，否则访问失败；

返回信息部件，用于根据访问信息部件所得的结果，返回结果信息。

8.如权利要求7所述的系统，其特征在于，所述存储信息部件采用以下步骤实现基于rank操作的哈希表存储过程：

1)将预处理的数据分为key和value数组，key[i]、value[i]与关键字、键值相对应；

2)预先一次性导入key值至bitmap中，定义哈希桶的数量为hash_bit，按照时间度O(1)的rank操作记录key数组的数据内容；对key与hash_bit取模得到h，确保落在哈希桶内，然后将h存储在哈希桶对应位置上，按照h值的大小，记录所有key值的相应位置信息；

3)存储计算C数组和D数组，利用rank操作从哈希表CB[0]开始记录C数组和D数组的相应信息；

4)利用C表和D表信息，计算每个key值对应的rank值；

5)利用rank值记录每个哈希桶内元素个数，按照哈希表C的顺序叠加记录，利用rank值作为顺序存储key、value值；

6)存储key、value值到数组中。

9.如权利要求7所述的系统，其特征在于，所述访问信息部件采用以下步骤实现基于rank操作的哈希表访问过程：

1)对要查询的数据key与hash_bit取模得到h；

2)计算q＝h&255，判断CB[h>>8].bitmap[q>>6]和(1<<(q&63))做与运算是否为1，即在原来哈希桶内是否有key值；若此步判断为0，则原哈希表内没有该key值，查询失败；若此步判断为1，则原哈希表内有该key值，则需要找到value值；

3)为了防止哈希冲突，即原哈希表内该位置有两个及以上的关键字值命中，则在该哈希桶内依次判断是否含有查询数据key，若包含，返回value值，若不包含，查询下一个关键字，直至关键字为空，查询失败。