精华内容
下载资源
问答
  • 哈希表:线性探测法和链地址法求查找成功与不成功的平均查找

    哈希表:线性探测法和链地址法求查找成功与不成功的平均查找长度

    了解ASL的公式

    查找成功时:ASL = 1 n \frac{1}{n} n1 ∑ i = 1 n C i \sum_{i=1}^{n} C_i i=1nCi
      n 为散列表中记录的个数( 不是表的长度 ),
      Ci 为查找成功的第 i 个记录所需要的比较次数( 表中空的记录意味着不成功,是不算在里面滴

    查找不成功时:ASL = 1 r \frac{1}{r} r1 ∑ i = 1 n C i \sum_{i=1}^{n} C_i i=1nCi
      r 为散列函数取值的个数( 不是表的长度 )。这个就充分解释了为什么散列函数 H(Key) = (key) MOD 11 在计算查找不成功ASL时,r = 11了,是因为这个散列函数的取值为 0~10,可以取11个值,所以 r = 11。
      Ci 为 散列函数取值为 i 时,查找失败时第 i 个记录所需要的比较次数( 表中的有些部分,散列函数根本取不到,自然也就不在计算里了

    我想只要把这两个公式看懂,查找成功与不成功的ASL也就自然会求了。下面线性探测法和链地址法我各举一个例子。

    线性探测法求ASL

    将关键字序列(7、8、30、11、18、9、14)散列存储到散列表中,散列函数为H(Key) = (key x 3) MOD 7,处理冲突采用线性探测再散列法,要求装填因子为0.7

    装填因子 a = 表 中 装 入 的 记 录 个 数 散 列 表 的 长 度 \frac{表中装入的记录个数}{散列表的长度} = 0.7,可以求出散列表表长 = 7 0.7 \frac{7}{0.7} 0.77 = 10
    (7x3)mod 7 = 0,因此散列地址为 0
    (8x3)mod 7 = 3,因此散列地址为 3
    (30x3)mod 7 = 6,因此散列地址为 6
    (11x3)mod 7 = 5,因此散列地址为 5
    (18x3)mod 7 = 5,此时和11冲突,使用线性探测法(地址+1),又和30冲突,地址再次+1,无冲突,散列地址为 7
    (9x3)mod 7 = 6,此时和30冲突,使用线性探测法(地址+1),又和18冲突,地址再次+1,无冲突,散列地址为 8
    (14x3)mod 7 = 0,此时和7冲突,使用线性探测法(地址+1),无冲突,散列地址为 1


    线性探测法处理冲突构造所得的哈希表如下:

    地址0123456789
    key71481130189

    根据公式:查找成功时ASL = 1 n \frac{1}{n} n1 ∑ i = 1 n C i \sum_{i=1}^{n} C_i i=1nCi
    如果查找7,则需要查找1次。
    如果查找8,则需要查找1次。
    如果查找30,则需要查找1次。
    如果查找11,则需要查找1次。
    如果查找18,则需要查找3次:第一次查找地址5,第二次查找地址6,第三次查找地址7,查找成功。
    如果查找9,则需要查找3次:第一次查找地址6,第二次查找地址7,第三次查找地址8,查找成功。
    如果查找14,则需要查找2次:第一次查找地址0,第二次查找地址1,查找成功。
    所以,查找成功时ASL=(1+2+1+1+1+3+3)/ 7 = 12/ 7

    根据公式:查找不成功时ASL = 1 r \frac{1}{r} r1 ∑ i = 1 n C i \sum_{i=1}^{n} C_i i=1nCi
    举个例子来说吧:
      如果要查找key为9的关键字。根据散列函数可以计算H(key)=H(9)=6。
      此时在会检测地址为6的值,发现key=30,不等于9。这就说明在装填的时候发生了冲突
      根据冲突处理方法,会继续检测地址为0的值,之所以没有检测地址7,8,9H(key)的取值取不到这些值。检测地址为0的值,发现key=7,依然不等
      根据冲突处理方法,会继续检测地址为1的值,发现key=14,依然不等
      根据冲突处理方法,会继续检测地址为2的值发现key为空
       这就说明关键字9从应该出现的地址6,一直查找,找到值为空的地址都没有和9相等的,说明散列表中没有9这个值,因此探测次数为4次

    根据上面的例子
    查找地址为0的值所需要的次数为3,
    查找地址为1的值所需要的次数为2,
    查找地址为2的值所需要的次数为1,
    查找地址为3的值所需要的次数为2,
    查找地址为4的值所需要的次数为1,
    查找地址为5的值所需要的次数为5,
    查找地址为6的值所需要的次数为4。
    所以,查找不成功ASL=(3+2+1+2+1+5+4)/ 7 = 18/ 7

    链地址法求ASL

    将关键字序列{1 13 12 34 38 33 27 22} 散列存储到散列表中。散列函数为:H(key)=key mod 11,处理冲突采用链地址法,求在等概率下查找成功和查找不成功的平均查找长度

    1mod11=1,因此散列地址为1
    13mod11=2,因此散列地址为2
    12mod11=1,因此散列地址为1(这个数据是数据1指针的另一个新数据)
    34mod11=1,因此散列地址为1(这个数据是数据12指针的另一个新数据)
    38mod11=5,因此散列地址为5
    33mod11=0,因此散列地址为0
    27mod11=5,因此散列地址为5(这个数据是数据38指针的另一个新数据)
    22mod11=0,因此散列地址为0(这个数据是数据33指针的另一个新数据)

    链地址法处理冲突构造所得的哈希表如下:
    在这里插入图片描述
    根据公式:查找成功时ASL = 1 n \frac{1}{n} n1 ∑ i = 1 n C i \sum_{i=1}^{n} C_i i=1nCi
    如果查找1,则需要查找3次。从地址1开始查,第一次查到34,第二次查到12,第三次查到1。
    如果查找13,则需要查找1次。
    如果查找12,则需要查找2次。从地址1开始查,第一次查到34,第二次查到12。
    如果查找34,则需要查找1次。
    如果查找38,则需要查找2次。从地址5开始查,第一次查到27,第二次查到38。
    如果查找33,则需要查找2次。从地址0开始查,第一次查到22,第二次查到33。
    如果查找27,则需要查找1次。
    如果查找22,则需要查找1次。
    所以,查找成功ASL =(3×1+2×3+1×4)/8 = 13/8

    根据公式:查找不成功时ASL = 1 r \frac{1}{r} r1 ∑ i = 1 n C i \sum_{i=1}^{n} C_i i=1nCi
    举个例子来说吧:
    如果要查找key为16的关键字。根据散列函数可以计算H(key)=H(16)=5。
      首先从地址5开始查找,第一次查找到的数据是27,和16不相等,继续往后找。
      第二次查找到的数据是38,和16不相等,继续往后找。
      第三次查找到的数据是空,查找结束。 意味着在地址5这一行找不到关键字16,因为如果关键字16在表中存在的话,只可能在地址5这一行,现在在地址5这一行找不到,意味着整个表也找不到。

    如果要查找key为20的关键字。根据散列函数可以计算H(key)=H(20)=9。
      首先从地址9开始查找,第一次查找到的数据是空,查找结束。意味着表中不存在关键字20。

    根据上面的例子
    查找地址为0的值所需要的次数为3,
    查找地址为1的值所需要的次数为4,
    查找地址为2的值所需要的次数为2,
    查找地址为3的值所需要的次数为1,
    查找地址为4的值所需要的次数为1,
    查找地址为5的值所需要的次数为3,
    查找地址为6的值所需要的次数为1,
    查找地址为7的值所需要的次数为1,
    查找地址为8的值所需要的次数为1,
    查找地址为9的值所需要的次数为1,
    查找地址为10的值所需要的次数为1。
    所以,查找不成功ASL = (3+4+2+1+1+3+1+1+1+1+1)/11 = 19/11

    其实不管是线性探测法还是链地址法,在求查找不成功ASL时,都是差不多的。首先根据散列函数找到地址,然后从这个地址往后查,一直查到空结束。

    展开全文
  • 也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。映射函数叫做散列函数,存放记录的数组叫做散列表。 装填因子         关键字个数 / 表长 处理冲突    ...

    散列表

            哈希表(Hash table,也叫散列表),是根据关键码值(Key value)而直接进行访问的数据结构。也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。映射函数叫做散列函数,存放记录的数组叫做散列表。

    装填因子

            关键字个数 / 表长

    处理冲突

            一般来说冲突不可避免的,只能尽可能地减少冲突的发生。在建立Hash表的时候必须进行冲突处理。
            下面主要介绍线性探测法:也是一种比较常用的处理冲突的方法(但是极易产生堆积问题)

    • 线性探测法 即从发生冲突的地址(记做d)开始,依次探查d的下一个地址,直至找到一个空位置为止。记住这句话。查找时若查到空位置还没有找到需要查找的元素则说明不在列表中,结合前一句话理解一下,还是比较容易理解的。这个为后面计算查找失败的平均长度提供了计算思路。
    • 链地址法 通过单链表将关键字连接起来,利用这种方法不会产生堆积问题。但是所谓的堆积问题,并不能完全通过利用单链表法来避免。毕竟并不是适用于任何问题,在能够利用链地址法不能解决冲突的问题,也许利用线性探测法可以有着不错的效果。

    性能分析

    即本文的主要内容,查找成功与查找失败的分析。

    • 查找成功平均查找长度即找到表中已有表项的平均比较次数
    • 查找失败平均查找长度即找不到待查的表项但能找到插入位置的平均比较次数

    平均查找长度的计算

    直接以题目来理解会比较快些:

            现有长度为11 且初始为空的散列表HT,散列函数H(key) = key % 7,采用线性探查法解决冲突。将关键字序列87,40,30,6,11,22,98,20 依次插入HT后,HT的查找失败的平均长度是多少呢? 查找成功的平均查找长度又是多少呢?
            ① 首先,通过散列函数并且利用线性探测法给他们每个字划分好自己的位置;
            ② 记录每个字冲突的次数,后面在计算查找成功的平均长度会用到;
            ③ 查找失败计算每个查找失败对应地址的查找次数,即从所查位置开始往后查直至查到空位置位置;
            ④ 其实,后面熟悉过程之后,在列出下面的每个关键字对应地址的表格之后就可以秒出答案;

    注意事项 查找失败时对应的地址在这个题目,只能是7 即 0~6 ;

    ASL 查找失败= (9 + 8 + 7 + 6 + 5 + 4 + 3 )/ 7 = 6

    ASL 查找成功= (1 + 1 + 1 + 1 + 1 + 1 + 1 + 2)/ 8 = 9 / 8

    散列地址012345678910
    关键字982230871140620
    冲突次数00000001

    OK,上面把例子说完了,可以再看看下面这个题目,来测试下是否理解了上面的那些需要注意的点。
            将关键字序列(7,8,30,11,18,9,14)散列存储到散列表中。散列表的存储空间是从0开始的一维数组,散列函数为H(key) = (3*key)mod 7,处理冲突采用线性探测法,要求装填因子为0.7。
            (1)画出所构造的散列表。
            (2)分别计算等概率情况下的查找成功和不成功的平均查找长度。(12/7 和 18/7

    (1)数组大小 = 7 / 0.7 = 10

    散列地址0123456789
    关键字71481130189

    (2)
            ①查找成功时

    散列地址0123456789
    关键字71481130189
    冲突次数0100022
    比较次数1211133

            ASL 查找成功= (1 + 2 + 1 + 1 + 1 + 3 + 3 )/ 7 = 12 / 7
            ②查找失败时

    散列地址0123456789
    关键字71481130189
    比较次数3212154

            ASL 查找失败= (3 + 2 + 1 + 2 + 5 + 4)/ 7 = 18 / 7

    【总结】简单吧,主要就是查找失败时除以的分母是 mod 后面的那个数,而不是关键字的个数。

    展开全文
  • 一、链地址在等概率下查找成功和查找不成功的平均查找长度:将关键字序列{1 13 12 34 38 33 27 22} 散列存储到散列表中。散列函数为:H(key)=key mod 11,处理冲突采用链地址,求在等概率下查找成功和查找不成功...

    一、链地址法在等概率下查找成功和查找不成功的平均查找长度:

    题目

    将关键字序列{1 13 12 34 38 33 27 22} 散列存储到散列表中。散列函数为:H(key)=key mod 11,处理冲突采用链地址法,求在等概率下查找成功和查找不成功的平均查找长度

    1mod11=1,所以数据1是属于地址1
    13mod11=2,所以数据13是属于地址2
    12mod11=1,所以数据12也是属于地址1(这个数据是数据1指针的另一个新数据)
    34mod11=1,所以数据34是属于地址1(这个数据是数据12指针的另一个新数据)
    38mod11=5,所以数据38是属于地址5
    33mod11=0,所以数据33是属于地址0
    27mod11=5,所以数据27是属于地址5,(这个数据是数据38指针的另一个新数据)
    22mod11=0,所以数据22是属于地址0,(这个数据是数据33指针的另一个新数据)

    链地址法处理冲突构造所得的哈希表如下:
    链地址法

    查找成功时: ASL=(3×1+2×3+1×4)/8=13/8, 其中红色标记为查找次数。也就是说,需查找1次找到的有4个,其它以此类推…

    查找不成功时:ASL=(3+4+2+1+1+3+1+1+1+1+1)/11=19/11;或者 ASL=(7×1+1×2+2×3+1×4 )/11=19/11,其中红色标记为查找次数。以第一个3为例,其对应于0地址位,确定查找不成功需比较3次,其它以此类推…

    原理:

    链地址法插入数据的时候采用采用头插法(插入每个链表的表头),因为习惯默认新插入进来的数据,马上就要访问到。下边是实现的伪代码

    CHAINED-HASH-INSERT(T, x)
        insert x at the head of list T[h(key[x])]
    CHAINED-HASH-SEARCH(T, k)
        search for an element with key k in list T[h(k)]
    CHAINED-HASH-DELETE(T, x)
         delete x from the list T[h(key[x])]
    
    例子

    例如,查找16的时候,根据散列函数在地址为5的链表查找,首先找到27,再找到38,然后找到38的后继节点为空,查找结束。查找结果失败,共查找3次。

    二,线性探测再散列法处理冲突

    对于这部分,个人觉得有人整理的比较好,很有条理,很清晰,可以借鉴一下,链接如下:
    线性探测再散列法处理冲突

    展开全文
  • 它通过把关键码值映射到哈希表中的一个位置来访问记录,以加快查找的速度。这个映射函数就做散列函数,存放记录的数组叫做散列表。 2、散列存储的基本思路  以数据中每个元素的关键字K为自变量,通过散列函数H(k)...

    一、哈希表

    1、概念

           哈希表(Hash Table)也叫散列表,是根据关键码值(Key Value)而直接进行访问的数据结构。它通过把关键码值映射到哈希表中的一个位置来访问记录,以加快查找的速度。这个映射函数就做散列函数,存放记录的数组叫做散列表。

    2、散列存储的基本思路

           以数据中每个元素的关键字K为自变量,通过散列函数H(k)计算出函数值,以该函数值作为一块连续存储空间的的单元地址,将该元素存储到函数值对应的单元中。

    3、哈希表查找的时间复杂度

           哈希表存储的是键值对,其查找的时间复杂度与元素数量多少无关,哈希表在查找元素时是通过计算哈希码值来定位元素的位置从而直接访问元素的,因此,哈希表查找的时间复杂度为O(1)。


    二、常用的哈希函数

    1.   直接寻址法

    取关键字或者关键字的某个线性函数值作为哈希地址,即H(Key)=Key或者H(Key)=a*Key+b(a,b为整数),这种散列函数也叫做自身函数.如果H(Key)的哈希地址上已经有值了,那么就往下一个位置找,知道找到H(Key)的位置没有值了就把元素放进去.

    2.   数字分析法

    分析一组数据,比如一组员工的出生年月,这时我们发现出生年月的前几位数字一般都相同,因此,出现冲突的概率就会很大,但是我们发现年月日的后几位表示月份和具体日期的数字差别很大,如果利用后面的几位数字来构造散列地址,则冲突的几率则会明显降低.因此数字分析法就是找出数字的规律,尽可能利用这些数据来构造冲突几率较低的散列地址.

    3.   平方取中法

    取关键字平方后的中间几位作为散列地址.一个数的平方值的中间几位和数的每一位都有关。因此,有平方取中法得到的哈希地址同关键字的每一位都有关,是的哈希地址具有较好的分散性。该方法适用于关键字中的每一位取值都不够分散或者较分散的位数小于哈希地址所需要的位数的情况。

    4.   折叠法

    折叠法即将关键字分割成位数相同的几部分,最后一部分位数可以不同,然后取这几部分的叠加和(注意:叠加和时去除进位)作为散列地址.数位叠加可以有移位叠加和间界叠加两种方法.移位叠加是将分割后的每一部分的最低位对齐,然后相加;间界叠加是从一端向另一端沿分割界来回折叠,然后对齐相加.

    5.   随机数法

    选择一个随机数,去关键字的随机值作为散列地址,通常用于关键字长度不同的场合.

    6.   除留余数法

    取关键字被某个不大于散列表表长m的数p除后所得的余数为散列地址.即H(Key)=Key MOD p,p<=m.不仅可以对关键字直接取模,也可在折叠、平方取中等运算之后取模。对p的选择很重要,一般取素数或m,若p选得不好,则很容易产生冲突。一般p取值为表的长度tableSize。


    三、哈希冲突的处理方法

    1、开放定址法——线性探测

    线性探测法的地址增量di = 1, 2, ... , m-1,其中,i为探测次数。该方法一次探测下一个地址,知道有空的地址后插入,若整个空间都找不到空余的地址,则产生溢出。

    线性探测容易产生“聚集”现象。当表中的第i、i+1、i+2的位置上已经存储某些关键字,则下一次哈希地址为i、i+1、i+2、i+3的关键字都将企图填入到i+3的位置上,这种多个哈希地址不同的关键字争夺同一个后继哈希地址的现象称为“聚集”。聚集对查找效率有很大影响。

    2、开放地址法——二次探测

    二次探测法的地址增量序列为 di = 12, -12, 22, -22,… , q2, -q(q <= m/2)。二次探测能有效避免“聚集”现象,但是不能够探测到哈希表上所有的存储单元,但是至少能够探测到一半。

    3、链地址法

    链地址法也成为拉链法。其基本思路是:将所有具有相同哈希地址的而不同关键字的数据元素连接到同一个单链表中。如果选定的哈希表长度为m,则可将哈希表定义为一个有m个头指针组成的指针数组T[0..m-1],凡是哈希地址为i的数据元素,均以节点的形式插入到T[i]为头指针的单链表中。并且新的元素插入到链表的前端,这不仅因为方便,还因为经常发生这样的事实:新近插入的元素最优可能不久又被访问。

    链地址法特点

    (1)拉链法处理冲突简单,且无堆积现象,即非同义词决不会发生冲突,因此平均查找长度较短; 
    (2)由于拉链法中各链表上的结点空间是动态申请的,故它更适合于造表前无法确定表长的情况; 
    (3)开放定址法为减少冲突,要求装填因子α较小,故当结点规模较大时会浪费很多空间。而拉链法中可取α≥1,且结点较大时,拉链法中增加的指针域可忽略不计,因此节省空间; 
    (4)在用拉链法构造的散列表中,删除结点的操作易于实现。只要简单地删去链表上相应的结点即可。而对开放地址法构造的散列表,删除结点不能简单地将被删结点的空间置为空,否则将截断在它之后填人散列表的同义词结点的查找路径。这是因为各种开放地址法中,空地址单元(即开放地址)都是查找失败的条件。因此在用开放地址法处理冲突的散列表上执行删除操作,只能在被删结点上做删除标记,而不能真正删除结点。

    四、哈希表的装填因子

    装填因子 = (哈希表中的记录数) /  (哈希表的长度)

    装填因子是哈希表装满程度的标记因子。值越大,填入表中的数据元素越多,产生冲突的可能性越大。


    五、不同处理冲突的平均查找长度

     

    例:

    假设散列表的长度是13,三列函数为H(K) = k % 13,给定的关键字序列为{32, 14, 23, 01, 42, 20, 45, 27, 55, 24, 10, 53}。分别画出用线性探测法和拉链法解决冲突时构造的哈希表,并求出在等概率情况下,这两种方法的查找成功和查找不成功的平均查找长度。

    (1)线性探测法:

    查找成功时的查找次数等于插入元素时的比较次数, 查找成功的平均查找长度为:

    ASL = (1+2+1+4+3+1+1+3+9+1+1+3)/12 = 2.5

    查找成功时的查找次数:第n个位置不成功时的比较次数为,第n个位置到第1个没有数据位置的距离:如第0个位置取值为1,第1个位置取值为2.

    查找不成功的平均查找次数为:

    ASL = (1+2+3+4+5+6+7+8+9+10+11+12)/ 13 = 91/13

    (2)链地址法

    查找成功时的平均查找长度:

    ASL = (1*6+2*4+3*1+4*1)/12 = 7/4

    查找不成功时的平均查找长度:

    ASL = (4+2+2+1+2+1)/13

    注意:查找成功时,分母为哈希表元素个数,查找不成功时,分母为哈希表长度。

    展开全文
  • Hash表线性探测处理计算比较成功和失败时的 ASL
  • 它通过把关键码值映射到哈希表中的一个位置来访问记录,以加快查找的速度。这个映射函数就做散列函数,存放记录的数组叫做散列表。 2、散列存储的基本思路 以数据中每个元素的关键字K为自变量,通过散列函数H(k)...
  • 试实现线性探测法查找函数。 函数接口定义: Position Find( HashTable H, ElementType Key ); 其中HashTable是开放地址散列表,定义如下: #define MAXTABLESIZE 100000 /* 允许开辟的最大散列表长度 */ typedef...
  • 线性探测法查找函数 (20 分)

    千次阅读 2018-12-07 14:57:18
    6-22 线性探测法查找函数 (20 分) 试实现线性探测法查找函数。 函数接口定义: Position Find( HashTable H, ElementType Key ); 其中HashTable是开放地址散列表,定义如下: #define MAXTABLESIZE 100000 /*...
  •  哈希表—线性探测法的ASL成功、不成功计算 将关键字序列(7、8、30、11、18、9、14)散列存储到散列表中。散列表的存储空间是一个下标从0开始的一维数组。散列函数为: H(key) = (keyx3) MOD 7,处理冲突采用线性...
  • //散列表查找——线性探测法 #include<iostream> #include<stdlib.h> using namespace std; void print(int list[],int e,int key,int a){ int n=e%key;//对输入的输求余 while(list[n]!=-1){ n...
  • 试实现线性探测法查找函数。 函数接口定义: Position Find( HashTable H, ElementType Key ); 其中HashTable是开放地址散列表,定义如下: #define MAXTABLESIZE 100000 /* 允许开辟的最大散列表长度 */ ...
  • 试实现线性探测法查找函数。 函数接口定义: Position Find( HashTable H, ElementType Key ); 其中HashTable是开放地址散列表,定义如下: #define MAXTABLESIZE 100000 /* 允许开辟的最大散列表长度 */ typedef...
  • 试实现线性探测法查找函数。 函数接口定义: Position Find( HashTable H, ElementType Key ); 其中HashTable是开放地址散列表,定义如下: #define MAXTABLESIZE 100000 /* 允许开辟的最大散列表长度 */ ...
  • 6-1 线性探测法查找函数 (20 分)

    千次阅读 2019-10-20 15:42:20
    试实现线性探测法查找函数。 函数接口定义: Position Find( HashTable H, ElementType Key ); 其中HashTable是开放地址散列表,定义如下: #define MAXTABLESIZE 100000 /* 允许开辟的最大散列表长度 */ typedef...
  • NULL 博文链接:https://128kj.iteye.com/blog/1744810
  • 试实现线性探测法查找函数。 函数接口定义: Position Find( HashTable H, ElementType Key ); 其中HashTable是开放地址散列表,定义如下: #define MAXTABLESIZE 100000 /* 允许开辟的最大散列表长度 */ typedef...
  • 哈希表-线性探测法理论 线性探测法的理论我们在上一篇博客已经阐述了。 现在我们来看看线性探测法的增删查的代码思想: 哈希表的增加元素: 注意:往后遍历寻找空闲位置的时候,要注意是环形遍历哦!不然访问数组...
  • 基于线性探测再散列的Hash表的“查找成功的ASL”和“查找不成功的ASL”ASL指的是 平均查找时间关键字序列:(7、8、30、11、18、9、14)散列函数: H(Key) = (key x 3) MOD 7装载因子: 0.7处理冲突:线性探测...
  • 习题5.10 线性探测法查找函数 (20分) 代码: Position Find( HashTable H, ElementType Key ) { int index = Hash(Key, H->TableSize), count = 0; while (count != H->TableSize) { if (H->Cells...
  • 6-4 线性探测法查找函数(哈希表)

    千次阅读 2017-12-15 15:52:22
    6-4线性探测法查找函数(20分) 试实现线性探测法查找函数。 函数接口定义: Position Find( HashTable H, ElementType Key ); 其中HashTable是开放地址散列表,定义如下: #define MAXTABLESIZE ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,195
精华内容 4,878
关键字:

线性探测法查找不成功怎么算

友情链接: fuzzypid.zip