散列函数的才散列算法解决冲突问题。散列函数的光散列算法解决冲突问题。

by admin on 2018年9月25日

1. 问题

1. 问题

问题同《粗略散列函数算法》

问题同《粗略散列函数算法》

存在10单非负整数,用不多让20只之贮存单元来存放,如何存放这10独数,使得搜索中的有一个往往时,在储存单元中搜寻的次数最少?

在10单非负整数,用不多吃20独之积存单元来存放,如何存放这10个数,使得搜索中的某个一个频时,在蕴藏单元中找寻的次数至少?

题目类似于,有10只带号码的球体,放到编号吧{0, 1, 2, …,
19}共20个盒子中,每个盒子最多放一个,问什么加大,使能够用极端少的次数打开盒子,知道不管一个球所在的盒子编号?

问题类似于,有10独带号码的球体,放到编号吧{0, 1, 2, …,
19}共20只盒子中,每个盒子最多放一个,问如何放,使能够用极端少之次数打开盒子,知道不管一个球所在的盒子编号?

 

 

2. 分析

2. 分析

《简散列函数算法》中,已经分析得出,只要能够解决冲突问题,就能用查找时间降为常量范围外。

《简单散列函数算法》中,已经分析得出,只要能迎刃而解冲突问题,就能用查找时间降呢常量范围外。

思路:当一个累起冲突时,再寻觅一个尚未于霸占的空盒子来放开是球

思路:当一个往往起冲突时常,再寻找一个没叫霸占的空盒子来放大之球

哈哈哈,思路相当简单,好像也深有道理的楷模,关键问题是:如何掌握者没占用的空盒子和球号的呼应关系?

哈哈,思路相当简单,好像也杀有道理的法,关键问题是:如何掌握之没占用的空盒子和球号的附和关系?

此地以《初当数论及其应用》中第5章节所介绍的计,该书被针对法的叙说有地方开展了简要,也从没言语怎么寻找,我这边开展补齐,并形容了份python的代码,便于理解以及运用

此处以《初当数论及其应用》中第5段所介绍的点子,该书中对法的叙说有地方进行了简要,也不曾开口如何寻找,我这里进行补齐,并形容了份python的代码,便于理解以及使用

 

 

3. 单散列函数解决冲突问题

3. 单散列函数解决冲突问题

3.1 方法的笔触:

3.1 方法的思路:

而盒子数量是m, 球的总额是n

苟盒子数量是m, 球的总数是n

当一个累起冲突常常,则看这冲突之盒子(k)的产一个盒子(k+1)是否是空的,如果是,则放入,如果不是,则持续看下下单(k+2),一直加到m,大于m还没找到,则到{0,
1, …, k}即k前面的盒子中错过探寻空盒子:

当一个累发冲突常常,则看这个冲突之盒子(k)的产一个盒子(k+1)是否是空的,如果是,则放入,如果未是,则持续看下下个(k+2),一直加到m,大于m还没有找到,则到{0,
1, …, k}即k前面的盒子中错过摸索空盒子:

如假设有球{0, 1, 30},仍若m = 10,当0和1独家放入对应的0,
1哀号盒子,当要放入30常常,f(30) = 30 % 10 =
0,0号盒子被占用,冲突,再拘留下一个盒子1号,发现1哀号为为霸占,再看下一个2声泪俱下盒子,发现凡是拖欠的,放入即可

如假设有球{0, 1, 30},仍使m = 10,当0和1独家放入对应的0,
1号盒子,当要放入30时不时,f(30) = 30 % 10 =
0,0号盒子被挤占,冲突,再看下一个盒子1如泣如诉,发现1号也于占据,再看下一个2哀号盒子,发现凡是空的,放入即可

当又闹一个圆球也40时呢,类似,会发现0, 1,
2声泪俱下盒子都让挤占,这时急需放入3号盒子

当以发生一个圆球也40时也,类似,会发现0, 1,
2声泪俱下盒子都受占用,这时急需放入3号盒子

那么此时又来一个真正的3声泪俱下球也,我们会意识3如泣如诉盒子都深受占据,所以只好放4号盒子中失矣

这就是说这又来一个真的的3如泣如诉球也,我们见面发现3号盒子都深受霸占,所以不得不坐4号盒子中去了

末段{0, 1, 30, 40, 3}放入的景况如下:

末了{0, 1, 30, 40, 3}放入的场面如下:

盒子1编号 0 1 2 3 4 5 6 7 8 9
球号 0 1 30 40 3          
盒子1编号 0 1 2 3 4 5 6 7 8 9
球号 0 1 30 40 3          

顾:这里由于球号的排顺序不同,放的职务并无均等,如球号如此排列{0, 1,
3, 30, 40},则3号球就会于3哀号位置了

瞩目:这里由于球号的排列顺序不同,放之位置并无平等,如球号如此排列{0, 1,
3, 30, 40},则3如泣如诉球就是见面在3号位置了

∵ 而m >= n

∵ 而m >= n

∴ 对于任一个x,总可以找到一个空的盒子给该放球

∴ 对于无一个x,总好找到一个缺损的盒子给其放球

 

 

3.2 数学表达式

3.2 数学表达式

设 h0(k) ≡ k (mod m), k = 球号, m = 盒子数量,这里”≡
”表示同余,不是齐,h(k)即为除m的余数

设 h0(k) ≡ k (mod m), k = 球号, m = 盒子数量,这里”≡
”表示同余,不是齐,h(k)即为除m的余数

hj(k) ≡ h0(k) + j,0<= j < m, 
hj(k) 表示出 j 次冲突后,球所放入的盒子编号

hj(k) ≡ h0(k) + j,0<= j < m, 
hj(k) 表示出 j 次冲突后,球所放入的盒子编号

∴ hj+1(k) ≡ h0(k) + (j + 1) ≡ hj(k) + 1

∴ hj+1(k) ≡ h0(k) + (j + 1) ≡ hj(k) + 1

即表示,当在hj(k)的位置发生冲突后,即再翻该下一个盒子是否为空

即表示,当在hj(k)的职务发生冲突后,即再查其下一个盒子是否也空

∵当k = m – 1不时, k ≡ 0 (mod m),根据模型的算法

∵当k = m – 1时, k ≡ 0 (mod m),根据模型的算法

∴其下一个职 k + 1 = 0,即表示回去0号盒子开始查找空盒子

∴其下一个职位 k + 1 = 0,即意味着回去0号盒子开始查找空盒子

 

 

3.3 如何寻找球k所于的盒子

3.3 如何寻找球k所于的盒子

道与放球时同样的,先查找h0(k) ≡ k (mod m), 如果相等,则ok

艺术和放球时同样的,先查找h0(k) ≡ k (mod m), 如果相等,则ok

一旦不顶,则证明或于产一个盒子中,按3.2底公式依次递归,最终见面找到相应之盒子

如果不顶,则证实可能于产一个盒子中,按3.2的公式依次递归,最终会找到相应之盒子

 

 

3.4 最坏复杂度

3.4 最坏复杂度

假设有9独球都占了{0, 1, 2, …, 8}前8单盒子,最后一个球k9
k0 (mod m),则用从第0个职位依次 +1
加到9岗位,才会找到不冲突之盒子,也就是说最老要开辟10个盒子才会找到,最坏复杂度
= n,n为球的数额,

设发生9独球就占据了{0, 1, 2, …, 8}前8个盒子,最后一个球k9
k0 (mod m),则要打第0个职务依次 +1
加至9职务,才能够找到不闯的盒子,也就是说最充分要打开10独盒子才能够找到,最坏复杂度
= n,n为球的数据,

哈哈,看起来费了一半天强还不设《简易散列函数算法》中的办法2.2。

哈哈哈,看起来费了一半上强还未设《简散列函数算法》中的法门2.2。

但便宜吗杀肯定,《简而言之散列函数算法》中的道2.2内需先对以第2组盒子中之球号进行排序,如果新增加一个球,就要再败一不好

然而利益呢十分鲜明,《大概散列函数算法》中的法子2.2得事先对以第2组盒子中的球号进行排序,如果新添一个圆球,就要再败一次等

 

 

3.5 Python code及测试结果

3.5 Python code及测试结果

#mod = m, h(k) = n % m, hj(k) = (h(k) + j) % m
def SingleHash(numList):
    if len(numList) > m:
        print "num list len is :", len(numList), "is big than mod :", m;
        return None;

    hashList = [None] * m;
    for k in numList:
        for j in range(m):
            hj_k = (k + j) % m;
            if None == hashList[hj_k]:
                hashList[hj_k] = k;
                break;
        else:
            print "num list is too big, hash list is overflow";
            return None;

    return hashList;

def CheckSingleHash(numList, hashList):
    if None == hashList:
        return;

    for k in numList:
        for j in range(m):
            hj_k = (k + j) % m;
            #check the key is equal with the one in hash list, if not check the next one
            if hashList[hj_k] == k:
                if j > 0:
                    print k, "find", j+1, "times";
                break;
            else:
                print k, "conflict with", hashList[hj_k]; 
        else:
            print k, "is not find...";
            return False;

    return True;
#mod = m, h(k) = n % m, hj(k) = (h(k) + j) % m
def SingleHash(numList):
    if len(numList) > m:
        print "num list len is :", len(numList), "is big than mod :", m;
        return None;

    hashList = [None] * m;
    for k in numList:
        for j in range(m):
            hj_k = (k + j) % m;
            if None == hashList[hj_k]:
                hashList[hj_k] = k;
                break;
        else:
            print "num list is too big, hash list is overflow";
            return None;

    return hashList;

def CheckSingleHash(numList, hashList):
    if None == hashList:
        return;

    for k in numList:
        for j in range(m):
            hj_k = (k + j) % m;
            #check the key is equal with the one in hash list, if not check the next one
            if hashList[hj_k] == k:
                if j > 0:
                    print k, "find", j+1, "times";
                break;
            else:
                print k, "conflict with", hashList[hj_k]; 
        else:
            print k, "is not find...";
            return False;

    return True;

测试时,设置了m = 19

测试时,设置了m = 19

测试数列为: numList = [0, 1, 2, 7, 9, 15, 19, 20, 77,
38],为了测试冲突,故意设置了有些冲突数,为了减少无用的输出,对于没冲的即使未自来了,测试结果如下:

测试数列为: numList = [0, 1, 2, 7, 9, 15, 19, 20, 77,
38],为了测试冲突,故意装了部分冲突数,为了削减无用的输出,对于无撞之就非由起了,测试结果如下:

betway必威 1

betway必威 2

可以看,38由于频繁冲,需要寻找7蹩脚才会找到

好望,38是因为反复扑,需要找7次等才能够找到

 

 

4. 散列算法冲突问题

4. 散列算法冲突问题

不论是《简言之散列函数算法》中之散列算法还是单散列算法,如果无撞的图景下,都设同破就可知找到球所在的盒子,所以若算法冲突的票房价值低,那么平均的工夫复杂度也是非常是进一步接近常量的。

不论是《简单易行散列函数算法》中的散列算法还是单散列算法,如果没撞之状况下,都使同蹩脚就是能够找到球所在的盒子,所以只要算法冲突之概率低,那么平均的时复杂度也是可怜是更接近常量的。

4.1 简单散列算法冲突之概率

4.1 简单散列算法冲突的几率

《简而言之散列函数算法》中的散列算法只要一个圆球k模m(k%m)已经以盒子中了,就势必会生出冲突,设k已于第一组盒子中,则针对具备的f(x)
= k + im, (i ∈ {0, 1, 2, …}),都见面来冲突,冲突的概率是杀高的。

《简言之散列函数算法》中的散列算法只要一个圆球k模m(k%m)已经以盒子中了,就必定会起冲突,设k已当首先组盒子中,则对具有的f(x)
= k + im, (i ∈ {0, 1, 2, …}),都见面出冲突,冲突之概率是可怜高的。

比方尽充分的球号为s, 则共有(s/m)个满足f(x) = k +
im的球号(当s特别充分时,可以忽略除未一味之局部)

设尽酷之球号为s, 则共有(s/m)个满足f(x) = k +
im的球号(当s不胜酷时,可以忽略除不老的一些)

则略散列函数算法中率先独为满足f(x) = k + im的圆球的票房价值 : 
betway必威 3

虽然略散列函数算法中率先只呢满足f(x) = k + im的圆球的票房价值 : 
betway必威 4

假若共有n个球,恰有2单球满足f(x)时,第2只圆球的概率:betway必威 5,当s很怪时,1得忽略,则约为
(n-1)/m

假定共有n个球,恰有2独球满足f(x)时,第2个圆球的票房价值:betway必威 6,当s很充分时,1得以忽略,则盖为
(n-1)/m

故刚好取2独圆球满足f(x)时之概率 = (n2-1)/m2

故刚好取2单球满足f(x)时之票房价值 = (n2-1)/m2

类之,恰有3个圆球满足f(x)时的票房价值 = n(n-1)(n-2) / m3

看似的,恰有3独球满足f(x)时之票房价值 = n(n-1)(n-2) / m3

足见见,当n和m接近时,冲突的票房价值越来越接近100%,所以自然要使m >
n,且大得越多越好

可观看,当n和m接近时,冲突之概率越来越接近100%,所以毫无疑问要是使m >
n,且大得越多越好

回去我们问题屡遭之设定,n = 10, m = 20, 则刚好2独球满足时,冲突之票房价值 =
25%

返回我们问题受到之设定,n = 10, m = 20, 则刚好2独球满足时,冲突之概率 =
25%

赶巧有3单球满足时,冲突之票房价值 = 9%

恰好有3独球满足时,冲突之几率 = 9%

究竟的扑概率 > 34%,冲突概率是深高的

总归的闯概率 > 34%,冲突概率是雅强的

 

 

4.2 单散列算法冲突概率

4.2 单散列算法冲突概率

单散列算法中,由于第一蹩脚有冲突常常,设为hj(k),第2次等发冲突时则必须出一个hj(k)

单散列算法中,由于第一次于发出冲突时,设为hj(k),第2差有冲突时常虽然须来一个hj(k)

  • 1
    的球体就在盒子中,所以产生2次之上冲突之几率会有着减退,当然,这种状况下是需要查阅2个盒子的。
  • 1
    的圆球就当盒子中,所以有2次之上冲突之几率会具备降低,当然,这种情况下是索要查阅2只盒子的。

是因为4.1知情,同时取出2个都满足f(x)时之概率 =
(n2-1)/m2,则第3只圆球要是f(x)或f(x)+1才见面betway必威时有发生冲突

是因为4.1了解,同时取出2单还满足f(x)时的票房价值 =
(n2-1)/m2,则第3独球要是f(x)或f(x)+1才会生冲突

第3个球是f(x)的概率 = (n-2)/m

第3个球是f(x)的概率 = (n-2)/m

第3个球是f(x) + 1的概率 = (n-2)/m,

第3个球是f(x) + 1的概率 = (n-2)/m,

所以发生冲突的票房价值 = 2n(n-1)(n-2) / m3

因而发生冲突的几率 = 2n(n-1)(n-2) / m3

其余大于3单球冲突的概率就不以为然计算比了,单用此和简单散列算法恰有2独球的闯比较:

旁大于3只圆球冲突之票房价值就反对计算比了,单用此和精炼散列算法恰有2个圆球的冲比较:

当n = 10, m = 20, 单散列算法冲突之几率 = 18%

当n = 10, m = 20, 单散列算法冲突之概率 = 18%

得视,单散列算法在这状下闯概率上是优化简单散列算法的。

足见到,单散列算法在这个情景下闯概率上是优于简单散列算法的。

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图