精华内容
下载资源
问答
  • 用C语言实现常用的字符串哈希函数,比如RSHash、JSHash、PJWHash、FNVHash等
  • 字符串哈希函数

    千次阅读 2019-01-23 11:05:11
    本文将介绍什么是字符串哈希函数字符串哈希函数常见用法,以及字符串哈希函数的实现原理和常用算法。 2、概念 哈希之所以广泛存在,是因为它能在绝大多数情况下可以在O(1)的时间复杂度中完成元素的查找。它的...

    原文地址:https://blog.csdn.net/mylinchi/article/details/79508112

    1、简介

    本文将介绍什么是字符串哈希函数,字符串哈希函数常见用法,以及字符串哈希函数的实现原理和常用算法。


    2、概念

    哈希之所以广泛存在,是因为它能在绝大多数情况下可以在O(1)的时间复杂度中完成元素的查找。它的核心是数组,如果输入是一个自然数,那么当然可以在常数时间内搜索到自然数所对应的数组元素了。但在工程实践中,要查找的关键字往往都不是自然数,即使是自然数也有可能是很大的值。因此,只要我们提前把关键字转换为在固定较小范围内的自然数,就可以实现常数时间的查找。那么问题来了,如何实现该转换关系呢?这就是哈希函数所要完成的工作。

    哈希函数:又称散列函数,是把一段有限二进制串(字符串,整数等)转换为自然数的一种函数。
    哈希值:哈希函数输出的最终结果。
    字符串哈希函数:输入是字符串的哈希函数。


    既然是函数,就有可能出现多对一的情况(多个输入对应同一个哈希值),这种情况称为冲突。没有冲突的哈希函数称为完全哈希函数,但这种函数只在理论分析中出现。为了保证每一个元素对应不同的存储地址,可使用以下两类方法:
    链接法:数组元素存储指向链表的指针,链表的每个元素都可以存储一个输入的元素。
    开放地址法:所有的元素都存放在散列表中,它不用指针,是计算出要存取的槽序列。

    使用哈希函数得到哈希值只是Hash算法的第一步,此外一般还需要进行高位运算和取模运算。


    3、常见方法

    评价hash函数性能的一个重要指标就是冲突,在相关资源允许的条件下冲突越少hash函数的性能越好。显然,对于字符串哈希函数,尽可能使每个字符都影响哈希值可以减少冲突。目前常见的字符串hash算法有BKDRHash,APHash,DJBHash,

    JSHash,RSHash,SDBMHash,PJWHash,ELFHash等等。

    使用网上提供的一份英语单词文件:http://www.cs.duke.edu/~ola/ap/linuxwords,共45402个单词,分别比较上面每一个算法在哈希表长度为100,1000和10000时的最大冲突数,理论上平均为455,46和5。结果如下:

    算法长度100的哈希长度1000的哈希长度10000的哈希
    bkdrhash5097214
    aphash5197215
    jshash4946615
    rshash5057415
    sdbmhash5186715
    pjwhash75613134
    elfhash80115891
    djbhash5126417
    dekhash5367522
    bphash1391696690
    fnvhash5166514
    javahash5236916

    其中数据1为100000个字母和数字组成的随机串哈希冲突个数。数据2为100000个有意义的英文句子哈希冲突个数。数据3为数据1的哈希值与 1000003(大素数)求模后存储到线性表中冲突的个数。数据4为数据1的哈希值与10000019(更大素数)求模后存储到线性表中冲突的个数。

    经过比较,得出以上平均得分。平均数为平方平均数。可以发现,BKDRHash无论是在实际效果还是编码实现中,效果都是最突出的。APHash也是较为优秀的算法。DJBHash,JSHash,RSHash与SDBMHash各有千秋。PJWHash与ELFHash效果最差,但得分相似,其算法本质是相似的。


    4、实现原理和常用算法

    所有的字符串哈希算法都是基于对字符编码的迭代运算,只是运算规则不同而已。
    1)BKDRHash算法

    BKDRHash是Kernighan和Dennis在《The C programming language》中提出的。这个算法的常数131是如何选取的,尚未可知,有知情者可以留言。

        // BKDR Hash Function
        unsigned int BKDRHash(char *str)
        {
            unsigned int seed = 131; // 31 131 1313 13131 131313 etc..
            unsigned int hash = 0;
         
            while (*str)
            {
                hash = hash * seed + (*str++);
            }
         
            return (hash & 0x7FFFFFFF);
        }

    关于BKDRHash算法的较为详细的解析可以参考BKDRHash详解。
    2)APHash算法

    Arash Partow提出了这个算法,声称具有很好地分布性。

        // AP Hash Function
        unsigned int APHash(char *str)
        {
            unsigned int hash = 0;
            int i;
         
            for (i=0; *str; i++)
            {
                if ((i & 1) == 0)
                {
                    hash ^= ((hash << 7) ^ (*str++) ^ (hash >> 3));
                }
                else
                {
                    hash ^= (~((hash << 11) ^ (*str++) ^ (hash >> 5)));
                }
            }
         
            return (hash & 0x7FFFFFFF);
        }

    3)DJBHash算法

    Daniel J. Bernstein在comp.lang.c邮件列表中发表的,是距今为止比较高效的哈希函数之一。

        // DJB Hash Function
        unsigned int DJBHash(char *str)
        {
            unsigned int hash = 5381;
         
            while (*str)
            {
                hash += (hash << 5) + (*str++);
            }
         
            return (hash & 0x7FFFFFFF);
        }

    4)JSHash算法

    Justin Sobel提出的基于位的函数函数。

       // JS Hash Function
        unsigned int JSHash(char *str)
        {
            unsigned int hash = 1315423911;
         
            while (*str)
            {
                hash ^= ((hash << 5) + (*str++) + (hash >> 2));
            }
         
            return (hash & 0x7FFFFFFF);
        }

    5)RSHash算法

    其作者是Robert Sedgwicks。实现如下:

        // RS Hash Function
        unsigned int RSHash(char *str)
        {
            unsigned int b = 378551;
            unsigned int a = 63689;
            unsigned int hash = 0;
         
            while (*str)
            {
                hash = hash * a + (*str++);
                a *= b;
            }
         
            return (hash & 0x7FFFFFFF);
        }

    6)SDBMHash算法

    SDBM项目使用的哈希函数,声称对所有的数据集有很好地分布性。

        unsigned int SDBMHash(char *str)
        {
            unsigned int hash = 0;
         
            while (*str)
            {
                // equivalent to: hash = 65599*hash + (*str++);
                hash = (*str++) + (hash << 6) + (hash << 16) - hash;
            }
         
            return (hash & 0x7FFFFFFF);
        }

    7)PJWHash算法

    Peter J. Weinberger在其编译器著作中提出的。

        // P. J. Weinberger Hash Function
        unsigned int PJWHash(char *str)
        {
            unsigned int BitsInUnignedInt = (unsigned int)(sizeof(unsigned int) * 8);
            unsigned int ThreeQuarters    = (unsigned int)((BitsInUnignedInt  * 3) / 4);
            unsigned int OneEighth        = (unsigned int)(BitsInUnignedInt / 8);
            unsigned int HighBits         = (unsigned int)(0xFFFFFFFF) << (BitsInUnignedInt - OneEighth);
            unsigned int hash             = 0;
            unsigned int test             = 0;
         
            while (*str)
            {
                hash = (hash << OneEighth) + (*str++);
                if ((test = hash & HighBits) != 0)
                {
                    hash = ((hash ^ (test >> ThreeQuarters)) & (~HighBits));
                }
            }
         
            return (hash & 0x7FFFFFFF);
        }

    8)ELFHash算法

    Unix系统上面广泛使用的哈希函数。

        // ELF Hash Function
        unsigned int ELFHash(char *str)
        {
            unsigned int hash = 0;
            unsigned int x    = 0;
         
            while (*str)
            {
                hash = (hash << 4) + (*str++);
                if ((x = hash & 0xF0000000L) != 0)
                {
                    hash ^= (x >> 24);
                    hash &= ~x;
                }
            }
         
            return (hash & 0x7FFFFFFF);
        }

    9)DEKHash算法

    Donald E. Knuth在《计算机程序设计的艺术》中提出的哈希函数。

    public static int dekhash(String str) {
          int hash = str.length();
    
          for (int i = 0; i < str.length(); i++) {
             hash = (hash << 5) ^ (hash >> 27) ^ (int)str.charAt(i);
          }
    
          return hash & 0x7FFFFFFF;
       }

    10)BPHash算法

    public static int bphash(String str) {
          int hash = str.length();
    
          for (int i = 0; i < str.length(); i++) {
             hash = (hash << 7) ^ (int)str.charAt(i);
          }
    
          return hash & 0x7FFFFFFF;
       }   

    11)FNVHash算法

    public static int fnvhash(String str) {
          int fnvprime = 0x811C9DC5;
          int hash = 0;
    
          for (int i = 0; i < str.length(); i++) {
             hash *= fnvprime;
             hash ^= (int)str.charAt(i);
          }
    
          return hash & 0x7FFFFFFF;
       }

    12)Java String Hashcode算法

    这是Java的字符串类的Hash算法,简单实用高效。直接从JDK6里面拿出来的代码:

    public static int javahash(String str) {
          int hash = 0;
    
          for (int i = 0; i < str.length(); i++) {
             hash = hash * 31 + (int)str.charAt(i);
          }
    
          return hash & 0x7FFFFFFF;
       }   

    ------------------------------------------------------------------------------------------------------------------------------

    参考文章:https://blog.csdn.net/u012834750/article/details/80005162

    一个股票交易系统的后台,为了能快速查找各种股票代码的Tick,会计算其哈希值,然后存贮在哈希表里面。一个好的哈希函数应该能实现很好地分布性,减少冲突。这里选取了几种常用的字符串哈希,包括BKDRHash,APHash,JSHash,RSHash,

    SDBMHash,PJWHash,ELFHash和DJBHash,通过在不同的字符串集合测试,来测试其性能。

    展开全文
  • 字符串哈希函数设计

    2014-05-11 11:36:15
    实验设计优化字符串哈希函数 比较经典字符串哈希函数 采用斐波那契函数思想
  • 哈希函数,是用来计算存储数据的哈希值的,根据存储数据的类型,可以设计不同的哈希函数。一个好的哈希函数(让哈希表效率高的函数),一般都具备下面两个特点: 速度快(别计算一个哈希值计算了半天,导致效率很低...

    在上一篇文章哈希表的大小提到过一种除留余数法的计算哈希值的函数。这一篇文章来具体说一说,怎么设计哈希函数能够让哈希表更加效率。

    哈希函数,是用来计算存储数据的哈希值的,根据存储数据的类型,可以设计不同的哈希函数。一个好的哈希函数(让哈希表效率高的函数),一般都具备下面两个特点:

    1. 速度快(别计算一个哈希值计算了半天,导致效率很低,简单高效就好)
    2. 能够将得到的哈希值均匀地分布在整个哈希表中,保证不产生聚集(不要让一堆数据都聚集在哈希表的一部分,这样之后的数据插入进来就很容易产生哈希冲突)

    通常一个哈希函数具有下面的形式

    哈希值 = 计算后的存储值 / 哈希表的大小

    对于如果存储的数是整数这种类型,我们完全可以不用计算,直接将整数的值作为上式中计算后的存储值。

    而对于字符串这种类型,当然不仅仅是字符串,我们都要设计一个相对较好的算法,来计算出它们的存储值。

    所以,我们以字符串为例,来介绍一下常见的字符串哈希算法,其他类型的数据都可以用相似的思路来设计适合自己的哈希算法。

    字符串哈希算法

    马上就能想到的算法:简单地将字符串中每个字符的ASCII码加起来

    size_t stringHash(const string& key){
        size_t hashKey = 0;
    
        for(size_t i = 0; i < key.size(); ++i)
            hashKey += key[i];
        
        return hashKey;
    }
    

    用上面的方法可以很快地算出哈希值,但是如果表很大时,则函数就不能很好的分配。比如我的表的大小是10000,即我的数据规模大概是7000个左右(取装填因子为0.7),但是我的字符最多只有8个字符长,由于ASCII码最大值是127,因此hash函数计算出来的哈希值只能在0-1016之间取值,其中127 * 8 =1016,这就会有一种聚集的效果,这就不是我们上面提到的两点想要的,我们要尽可能地避免聚集。

    这个方法可能是刚接触字符串哈希函数的人会马上想到的,但其实我们有很多的优秀的字符串哈希算法。

    优秀的字符串哈希算法

    BKDR哈希算法

    size_t BKDR_hash(const string& key){
        size_t hashKey = 0;
        size_t seed = 131;    //也可以是31 131 1313 13131 131313
        for(size_t i = 0; i < key.size(); ++i)
            hashKey += hashKey * seed + key[i];
    
        return hashKey;
    }
    

    根据上面的算法,我们就可以根据结果得到非聚合的一些哈希值。

    这个算法是效率很高的一个算法,其他的字符串算法可以看这里:字符串哈希算法,是人家总结的一篇文章,涵盖了当今很多的哈希算法。

    展开全文
  • Little trick.1 哈希函数理想的哈希函数保证每个字符串对应唯一的哈希值。下面这个哈希函数是同学在项目中遇到的。unsigned int hash(char* s){unsigned int h=0;for(;*s;s++)h = *s + h*31;return h%HASHSIZE; //...

    Little trick.

    1 哈希函数

    理想的哈希函数保证每个字符串对应唯一的哈希值。下面这个哈希函数是同学在项目中遇到的。

    unsigned int hash(char* s)

    {

    unsigned int h=0;

    for(;*s;s++)

    h = *s + h*31;

    return h%HASHSIZE; //predefined hash size

    }

    可以看出,这个hash函数遍历字符串中每个字符,通过将其ASCII码计算得到最终的哈希值h。 这样来确保前面提到的结果唯一性。 我们在gdb中验证一下,有char*类型的字符串s为nnmm。s的第i个字符用s[i]或者*(s+i)表示。

    (gdb) p s

    $8 = 0x40071c "nnmm"

    (gdb) p s[0]

    $11 = 110 'n'

    (gdb) p s[1]

    $12 = 110 'n'

    (gdb) p s[2]

    $13 = 109 'm'

    (gdb) p *s

    $9 = 110 'n'

    (gdb) p *s+1

    $10 = 111

    (gdb) p *(s+1)

    $14 = 110 'n'

    (gdb) p *(s+2)

    $15 = 109 'm'

    可以看到,直接打印第i个字符的同时也会输出该字符的ASCII码。 第i个字符在公式中转成ASCII码,然后算出unsigned int型的h。

    ASCII码对照表

    9fb5e7e62c361485561fce55ec2eebee.png

    1.1 哈希函数的对比

    [1]中提到编程珠玑中的一个hash函数也是用的类似方法,代码如下:

    //用跟元素个数最接近的质数作为散列表的大小

    #define NHASH 29989

    #define MULT 31

    unsigned in hash(char *p)

    {

    unsigned int h = 0;

    for (; *p; p++)

    h = MULT *h + *p;

    return h % NHASH;

    }

    除此之外,[1]还对常用字符串哈希函数 BKDRHash,APHash,DJBHash,JSHash,RSHash,SDBMHash,PJWHash,ELFHash进行了量化比较。

    1.2 哈希函数分类

    [2]中把哈希函数分为如下几类:

    加法Hash;

    位运算Hash;

    乘法Hash;

    除法Hash;

    查表Hash;

    混合Hash;

    其中我们上文的函数属于乘法Hash,这种类型的Hash函数利用了乘法的不相关性(乘法的这种性质,最有名的莫过于平方取头尾的随机数生成算法,虽然这种算法效果并不好)。

    jdk5.0里面的String类的hashCode()方法也使用乘法Hash。不过,它使用的乘数是31。推荐的乘数还有:131, 1313, 13131, 131313等等。

    Reference

    2 字符串深度复制

    char* str_dump(char* s)

    {

    int l=strlen(s)+1;

    char* ns=(char*)malloc(l*sizeof(char));

    strcpy(ns,s);//char *strcpy(char* dest, const char *src)

    return ns;// possible be NULL

    }

    展开全文
  • 字符串哈希

    万次阅读 多人点赞 2019-04-29 11:44:23
    使用自然溢出时数据量不应太大,因为要用到map,(数组...字符串哈希 即将一个字符串转化成一个整数,并保证字符串不同,得到的哈希值不同,这样就可以用来判断一个该字串是否重复出现过。 (如果直接把string当做...
    • 使用自然溢出时数据量不应太大,因为要用到map,(数组不够开ull!),map会自动排序,所以会超时。所以超过5*10^5就别用自然溢出了,找到最大可能值即可。
    • 一般乘以素数p(131,13331,2333等)或最大值,然后%素数1e9+7

    字符串哈希

    即将一个字符串转化成一个整数,并保证字符串不同,得到的哈希值不同,这样就可以用来判断一个该字串是否重复出现过。

    (如果直接把string当做键,则每次在map中查找时要一个一个字符地找,跟存在数组中每区别,比较数值当然更快。)

    由哈希函数的性质,对于一个字符串:S=s1s2...sn,我们把每个字符转换成idx(si)=si-'a'+1 当然直接用字符串的ASCII码表示也可以,则哈希模型为Hash(i)=Hash(i-1)*p+idx(si),其中p为素数。最终算出的Hash(n)作为该字符串的哈希值。所以构造哈希函数的关键点在于使不同字符串的哈希冲突率尽可能小。下面介绍几种哈希函数:

    哈希方法

    • 自然溢出方法:利用unsigned long long 自然溢出,相当于自动对2^64−1取模

     定义哈希函数:unsigned long long hash[n];

    公式:Hash[i] = Hash[i-1]*p+idx(si)

    • 单哈希方法

    公式:Hash[i] = (Hash[i-1]*p+idx(si))%mod

    p,mod均为质数,p<mod,p,mod取尽量大时冲突很小

    • 双哈希方法:将字符串用不同mod单哈希两次,结果用二元组表示

    Hash1[i] = (Hash1[i-1]*p+idx(si))%mod

    Hash2[i] = (Hash2[i-1]*p+idx(si))%mod

    Hash[i]:<Hash1[i],Hash2[i]>

    这种方法很安全

    求出一个串的哈希值后得到字串的哈希值:o(1)

    素数的选择

    像1e9+7等常见素数很可能被出题人卡,所以可以选择一些其他的素数,像2333等

    下面求两个串中同字母异构的个数,不关心排列顺序,所以哈希时从a~z遍历取个数。

    #include<bits/stdc++.h>
    using namespace std;
    typedef long long ll;
    typedef unsigned long long ull;
    #define far(i,t,n) for(int i=t;i<n;++i)
    
    char a[4050],b[4050];
    map<ull,ll>hashS;
    map<ull,ll>::iterator it;
    ull cnt[30];
    ull p=1e9+7;
    
    ull getHash()
    {
        ull ans=26;
        far(i,0,26)
        {
            ans*=p;
            ans+=cnt[i];
        }
        return ans;
    }
    
    int main()
    {
        scanf("%s%s",a,b);
        int la=strlen(a),lb=strlen(b);
        int l=min(la,lb);
        int ans=0;
        for(int i=1;i<=l;++i)
        {
            hashS.clear();
            memset(cnt,0,sizeof(cnt));
            for(int j=0;j<i;j++)
                cnt[a[j]-'a']++;
            for(int j=0;i+j<la;++j)
            {
                hashS[getHash()]++;
                cnt[a[j]-'a']--;
                cnt[a[i+j]-'a']++;
            }
    
            hashS[getHash()]++;
            memset(cnt,0,sizeof(cnt));
            for(int j=0;j<i;j++)
                cnt[b[j]-'a']++;
            for(int j=0;i+j<lb;++j)
            {
                if(hashS[getHash()])
                    ans=max(ans,i);
                cnt[b[j]-'a']--;
                cnt[b[i+j]-'a']++;
    
            }
            if(hashS[getHash()])ans=max(ans,i);
        }
        printf("%d\n",ans);
        return 0;
    }

     如果需要算出一个字符串长度为n的所有子串,则提前预处理出0~i的哈希值hash[i],则可以以0(1)的复杂度算出[l,r]的哈希值

    #include<bits/stdc++.h>
    using namespace std;
    #define far(i,t,n) for(int i=t;i<n;++i)
    typedef long long ll;
    typedef unsigned long long ull;
    
    char t[1000010];
    char w[10010];
    const int p=12582917;
    ull po[10010];
    ull Hash[1000010];
    
    void initPo()//预处理p^(r-l+1)
    {
        po[0]=1;
        po[1]=p;
        far(i,2,10002)
            po[i]=po[i-1]*p;
    }
    
    ull getSingleHash(char c[],int n)
    {
        Hash[0]=c[0]-'A';
        far(i,1,n)
        {
            Hash[i]=Hash[i-1]*p;
            Hash[i]+=c[i]-'A';
        }
    }
    
    ull getHash(int l,int r)
    {
        if(l==0)
            return Hash[r];
        return Hash[r]-Hash[l-1]*po[r-l+1];
    }
    
    int main()
    {
        int Kase;
        cin>>Kase;
        initPo();
        while(Kase--)
        {
            scanf("%s%s",w,t);
            int lw=strlen(w),lt=strlen(t);
            ull x=w[0]-'A';
            far(i,1,lw)
                x=x*p+(w[i]-'A');
            getSingleHash(t,lt);
            int ans=0;
            for(int i=0;i<=lt-lw;++i)
            {
               // cout<<i<<" "<<getHash(i,i+lw)<<endl;
                if(x==getHash(i,i+lw-1))
                    ++ans;
            }
    
            printf("%d\n",ans);
        }
    
        return 0;
    }

    参考:https://blog.csdn.net/pengwill97/article/details/80879387

    展开全文
  • 几个经典的字符串哈希函数及测试.rar
  • js 字符串哈希函数

    2016-02-29 11:24:00
    * 获取字符串哈希值 * @param {String} str * @param {Boolean} caseSensitive * @return {Number} hashCode */ getHashCode:function(str,caseSensitive){ if(!caseSensitive){ str = str...
  • 字符串哈希(详解+模版)

    千次阅读 2018-12-09 19:17:32
    字符串Hash的种类还是有很多种的,不过在ACM中一般只会用到一种名为“BKDR Hash”的字符串Hash算法。它的主要思路是选取恰当的进制,可以把字符串中的字符看成一个大数字中的每一位数字。关于进制的选择实际上非常...
  • 本文实例讲述了C#计算字符串哈希值(MD5、SHA)的方法。分享给大家供大家参考。具体如下: 一、关于本文 本文中是一个类库,包括下面几个函数: ① 计算32位MD5码(大小写):Hash_MD5_32 ② 计算16位MD5码(大小写...
  • 字符串哈希算法

    千次阅读 2020-02-02 12:37:26
    字符串哈希算法,通俗的理解,就是将一个字符串,转化成整数 原来我们进行字符串匹配的时候,就是一个个去匹配,那么时间复杂度是o(n),如果转化成数字,去匹配那么时间复杂度会变成o(1)。 哈希算法的引入 ...
  • golang实现字符串哈希 算法题目 给定一个长度为n的字符串,再给定m个询问,每个询问包含四个整数l1,r1,l2,r2,请你判断[l1,r1]和[l2,r2]这两个区间所包含的字符串子串是否完全相同。 字符串中只包含大小写英文字母...
  • 这里选取了几种常用的字符串哈希,包括BKDRHash,APHash,JSHash,RSHash,SDBMHash,PJWHash,ELFHash和DJBHash,通过在不同的字符串集合测试,来测试其性能。 各种常用算法 一、BKD...
  • hsh是一个完全用Rust编写的简单的字符串哈希CLI,它支持多种哈希函数。 它主要依靠来执行哈希。 支持的哈希函数 (GOST R 34.11-9)(同时带有“测试参数”和CryptoPro ) Grøstl224 Grøstl256 Grøstl384 ...
  • 字符串哈希到整数函数,算法

    千次阅读 2019-01-06 09:49:09
    基本概念 所谓完美哈希函数,就是指没有冲突的哈希函数,即对任意的 key1 != key2 有h(key1) != h(key2)。 设定义域为X,值域为Y, n=|X|,m=|Y|,那么肯定有m&...在处理大规模字符串数据时,...
  • 各种字符串哈希函数

    2014-07-17 11:19:24
    常用的字符串Hash函数还有ELFHash,APHash等等,都是十分简单有效的方法。...常用字符串哈希函数有BKDRHash,APHash,DJBHash,JSHash,RSHash,SDBMHash,PJWHash,ELFHash等等。对于以上几种哈希函数,我对其进
  • MySQL中字符函数①length函数获取参数值的字节个数语法:select length(参数);...③upper、lowerupper将字符串全部转换成大写的字符lower将字符串全部转换成小写的字符select upper(‘lmz’);④s...
  • 各种字符串Hash函数(转)

    千次阅读 2021-02-13 00:54:47
    ///@brief BKDR Hash Function///@detail 本 算法由于在Brian Kernighan与Dennis Ritchie的《The C Programming Language》一书被展示而得 名,是一种简单快捷的hash算法,也是Java目前采用的字符串的Hash算法(累乘...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 126,184
精华内容 50,473
关键字:

字符串哈希函数

友情链接: mspaint.rar