字符串Hash函数评估

最新推荐文章于 2024-04-14 09:37:14 发布
最新推荐文章于 2024-04-14 09:37:14 发布
阅读量606 收藏 1
点赞数 1
分类专栏： 数据结构和算法 文章标签： function conflict struct null algorithm insert
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jackfirst86/article/details/6293449
版权

Hash查找因为其O(1)的查找性能而著称，被对查找性能要求高的应用所广泛采用。它的基本思想是：
(1) 创建一个定长的线性Hash表，一般可以初始化时指定length;

(2) 设计Hash函数，将关键字key散射到Hash表中。其中hash函数设计是最为关键的，均匀分布、冲突概率小全在它；

(3) 通常采用拉链方法来解决hash冲突问题，即散射到同一个hash表项的关键字，以链表形式来表示(也称为桶backet);

(4) 给定关键字key，就可以在O(1) + O(m)的时间复杂度内定位到目标。其中，m为拉链长度，即桶深。

Hash应用中，字符串是最为常见的关键字，应用非常普通，现在的程序设计语言中基本上都提供了字符串hash表的支持。字符串hash函数非常多，常见的主要有Simple_hash, RS_hash, JS_hash, PJW_hash, ELF_hash, BKDR_hash, SDBM_hash, DJB_hash, AP_hash, CRC_hash等。它们的C语言实现见后面附录代码: hash.h, hash.c。那么这么些字符串hash函数，谁好熟非呢？评估hash函数优劣的基准主要有以下两个指标：

(1) 散列分布性

即桶的使用率backet_usage = (已使用桶数) / (总的桶数)，这个比例越高，说明分布性良好，是好的hash设计。

(2) 平均桶长

即avg_backet_len，所有已使用桶的平均长度。理想状态下这个值应该=1，越小说明冲突发生地越少，是好的hash设计。

hash函数计算一般都非常简洁，因此在耗费计算时间复杂性方面判别甚微，这里不作对比。

评估方案设计是这样的：

(1) 以200M的视频文件作为输入源，以4KB的块为大小计算MD5值，并以此作为hash关键字;

(2) 分别应用上面提到的各种字符串hash函数，进行hash散列模拟；

(3) 统计结果，用散列分布性和平均桶长两个指标进行评估分析。

测试程序见附录代码hashtest.c，测试结果如下表所示。从这个结果我们也可以看出，这些字符串hash函数真是不相仲伯，难以决出高低，所以实际应用中可以根据喜好选择。当然，最好实际测试一下，毕竟应用特点不大相同。其他几组测试结果也类似，这里不再给出。

Hash函数 桶数 Hash调用总数 最大桶长 平均桶长 桶使用率%
simple_hash 10240 47198 16 4.63 99.00%
RS_hash 10240 47198 16 4.63 98.91%
JS_hash 10240 47198 15 4.64 98.87%
PJW_hash 10240 47198 16 4.63 99.00%
ELF_hash 10240 47198 16 4.63 99.00%
BKDR_hash 10240 47198 16 4.63 99.00%
SDBM_hash 10240 47198 16 4.63 98.90%
DJB_hash 10240 47198 15 4.64 98.85%
AP_hash 10240 47198 16 4.63 98.96%
CRC_hash 10240 47198 16 4.64 98.77%


附录源代码：

hash.h

view plaincopy to clipboardprint?
#ifndef _HASH_H  
#define _HASH_H  
 
#ifdef __cplusplus  
extern "C" {  
#endif  
 
/* A Simple Hash Function */ 
unsigned int simple_hash(char *str);  
 
/* RS Hash Function */ 
unsigned int RS_hash(char *str);  
 
/* JS Hash Function */ 
unsigned int JS_hash(char *str);  
 
/* P. J. Weinberger Hash Function */ 
unsigned int PJW_hash(char *str);  
 
/* ELF Hash Function */ 
unsigned int ELF_hash(char *str);  
 
/* BKDR Hash Function */ 
unsigned int BKDR_hash(char *str);  
 
/* SDBM Hash Function */ 
unsigned int SDBM_hash(char *str);  
 
/* DJB Hash Function */ 
unsigned int DJB_hash(char *str);  
 
/* AP Hash Function */ 
unsigned int AP_hash(char *str);  
 
/* CRC Hash Function */ 
unsigned int CRC_hash(char *str);  
 
#ifdef __cplusplus  
}  
#endif  
 
#endif 
#ifndef _HASH_H
#define _HASH_H

#ifdef __cplusplus
extern "C" {
#endif

/* A Simple Hash Function */
unsigned int simple_hash(char *str);

/* RS Hash Function */
unsigned int RS_hash(char *str);

/* JS Hash Function */
unsigned int JS_hash(char *str);

/* P. J. Weinberger Hash Function */
unsigned int PJW_hash(char *str);

/* ELF Hash Function */
unsigned int ELF_hash(char *str);

/* BKDR Hash Function */
unsigned int BKDR_hash(char *str);

/* SDBM Hash Function */
unsigned int SDBM_hash(char *str);

/* DJB Hash Function */
unsigned int DJB_hash(char *str);

/* AP Hash Function */
unsigned int AP_hash(char *str);

/* CRC Hash Function */
unsigned int CRC_hash(char *str);

#ifdef __cplusplus
}
#endif

#endif
 

hash.c

view plaincopy to clipboardprint?
#include <string.h>  
#include "hash.h"  
 
/* A Simple Hash Function */ 
unsigned int simple_hash(char *str)  
{  
    register unsigned int hash;  
    register unsigned char *p;  
 
    for(hash = 0, p = (unsigned char *)str; *p ; p++)  
        hash = 31 * hash + *p;  
 
    return (hash & 0x7FFFFFFF);  
}  
 
/* RS Hash Function */ 
unsigned int RS_hash(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);  
}  
 
/* JS Hash Function */ 
unsigned int JS_hash(char *str)  
{  
         unsigned int hash = 1315423911;  
 
         while (*str)  
         {  
                 hash ^= ((hash << 5) + (*str++) + (hash >> 2));  
         }  
          
         return (hash & 0x7FFFFFFF);  
}  
 
/* P. J. Weinberger Hash Function */ 
unsigned int PJW_hash(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);  
}  
 
/* ELF Hash Function */ 
unsigned int ELF_hash(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);  
}  
 
/* BKDR Hash Function */ 
unsigned int BKDR_hash(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);  
}  
 
/* SDBM Hash Function */ 
unsigned int SDBM_hash(char *str)  
{  
         unsigned int hash = 0;  
 
         while (*str)  
         {  
                 hash = (*str++) + (hash << 6) + (hash << 16) - hash;  
         }  
 
         return (hash & 0x7FFFFFFF);  
}  
 
/* DJB Hash Function */ 
unsigned int DJB_hash(char *str)  
{  
         unsigned int hash = 5381;  
 
         while (*str)  
         {  
                 hash += (hash << 5) + (*str++);  
         }  
 
         return (hash & 0x7FFFFFFF);  
}  
 
/* AP Hash Function */ 
unsigned int AP_hash(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);  
}  
 
/* CRC Hash Function */ 
unsigned int CRC_hash(char *str)  
{  
    unsigned int        nleft   = strlen(str);  
    unsigned long long  sum     = 0;  
    unsigned short int *w       = (unsigned short int *)str;  
    unsigned short int  answer  = 0;  
 
    /* 
     * Our algorithm is simple, using a 32 bit accumulator (sum), we add 
     * sequential 16 bit words to it, and at the end, fold back all the 
     * carry bits from the top 16 bits into the lower 16 bits. 
     */ 
    while ( nleft > 1 ) {  
        sum += *w++;  
        nleft -= 2;  
    }  
    /* 
     * mop up an odd byte, if necessary 
     */ 
    if ( 1 == nleft ) {  
        *( unsigned char * )( &answer ) = *( unsigned char * )w ;  
        sum += answer;  
    }  
    /* 
     * add back carry outs from top 16 bits to low 16 bits 
     * add hi 16 to low 16 
     */ 
    sum = ( sum >> 16 ) + ( sum & 0xFFFF );  
    /* add carry */ 
    sum += ( sum >> 16 );  
    /* truncate to 16 bits */ 
    answer = ~sum;  
 
    return (answer & 0xFFFFFFFF);  
} 
#include <string.h>
#include "hash.h"

/* A Simple Hash Function */
unsigned int simple_hash(char *str)
{
    register unsigned int hash;
    register unsigned char *p;

    for(hash = 0, p = (unsigned char *)str; *p ; p++)
        hash = 31 * hash + *p;

    return (hash & 0x7FFFFFFF);
}

/* RS Hash Function */
unsigned int RS_hash(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);
}

/* JS Hash Function */
unsigned int JS_hash(char *str)
{
         unsigned int hash = 1315423911;

         while (*str)
         {
                 hash ^= ((hash << 5) + (*str++) + (hash >> 2));
         }
       
         return (hash & 0x7FFFFFFF);
}

/* P. J. Weinberger Hash Function */
unsigned int PJW_hash(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);
}

/* ELF Hash Function */
unsigned int ELF_hash(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);
}

/* BKDR Hash Function */
unsigned int BKDR_hash(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);
}

/* SDBM Hash Function */
unsigned int SDBM_hash(char *str)
{
         unsigned int hash = 0;

         while (*str)
         {
                 hash = (*str++) + (hash << 6) + (hash << 16) - hash;
         }

         return (hash & 0x7FFFFFFF);
}

/* DJB Hash Function */
unsigned int DJB_hash(char *str)
{
         unsigned int hash = 5381;

         while (*str)
         {
                 hash += (hash << 5) + (*str++);
         }

         return (hash & 0x7FFFFFFF);
}

/* AP Hash Function */
unsigned int AP_hash(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);
}

/* CRC Hash Function */
unsigned int CRC_hash(char *str)
{
    unsigned int        nleft   = strlen(str);
    unsigned long long  sum     = 0;
    unsigned short int *w       = (unsigned short int *)str;
    unsigned short int  answer  = 0;

    /*
     * Our algorithm is simple, using a 32 bit accumulator (sum), we add
     * sequential 16 bit words to it, and at the end, fold back all the
     * carry bits from the top 16 bits into the lower 16 bits.
     */
    while ( nleft > 1 ) {
        sum += *w++;
        nleft -= 2;
    }
    /*
     * mop up an odd byte, if necessary
     */
    if ( 1 == nleft ) {
        *( unsigned char * )( &answer ) = *( unsigned char * )w ;
        sum += answer;
    }
    /*
     * add back carry outs from top 16 bits to low 16 bits
     * add hi 16 to low 16
     */
    sum = ( sum >> 16 ) + ( sum & 0xFFFF );
    /* add carry */
    sum += ( sum >> 16 );
    /* truncate to 16 bits */
    answer = ~sum;

    return (answer & 0xFFFFFFFF);
}

 

hashtest.c

view plaincopy to clipboardprint?
#include <stdio.h>  
#include <stdlib.h>  
#include <sys/types.h>  
#include <sys/stat.h>  
#include <fcntl.h>  
#include <errno.h>  
#include <string.h>  
#include "hash.h"  
#include "md5.h"  
 
struct hash_key {  
    unsigned char *key;  
    struct hash_key *next;   
};  
 
struct hash_counter_entry {  
    unsigned int hit_count;  
    unsigned int entry_count;  
    struct hash_key *keys;  
};  
 
#define BLOCK_LEN   4096  
 
static int backet_len = 10240;  
static int hash_call_count = 0;  
static struct hash_counter_entry *hlist = NULL;  
unsigned int (*hash_func)(char *str);  
 
void choose_hash_func(char *hash_func_name)  
{  
    if (0 == strcmp(hash_func_name, "simple_hash"))  
        hash_func = simple_hash;  
    else if (0 == strcmp(hash_func_name, "RS_hash"))  
        hash_func = RS_hash;  
    else if (0 == strcmp(hash_func_name, "JS_hash"))  
        hash_func = JS_hash;  
    else if (0 == strcmp(hash_func_name, "PJW_hash"))  
        hash_func = PJW_hash;  
    else if (0 == strcmp(hash_func_name, "ELF_hash"))  
        hash_func = ELF_hash;  
    else if (0 == strcmp(hash_func_name, "BKDR_hash"))  
        hash_func = BKDR_hash;  
    else if (0 == strcmp(hash_func_name, "SDBM_hash"))  
        hash_func = SDBM_hash;  
    else if (0 == strcmp(hash_func_name, "DJB_hash"))  
        hash_func = DJB_hash;  
    else if (0 == strcmp(hash_func_name, "AP_hash"))  
        hash_func = AP_hash;  
    else if (0 == strcmp(hash_func_name, "CRC_hash"))  
        hash_func = CRC_hash;  
    else 
        hash_func = NULL;  
}  
 
void insert_hash_entry(unsigned char *key, struct hash_counter_entry *hlist)  
{  
    unsigned int hash_value = hash_func(key) % backet_len;  
    struct hash_key *p;  
 
    p = hlist[hash_value].keys;  
    while(p) {  
        if (0 == strcmp(key, p->key))  
            break;  
        p = p->next;  
    }  
    if (p == NULL)  
    {  
        p = (struct hash_key *)malloc(sizeof(struct hash_key));  
        if (p == NULL)   
        {  
            perror("malloc in insert_hash_entry");  
            return;  
        }  
        p->key = strdup(key);  
        p->next = hlist[hash_value].keys;  
        hlist[hash_value].keys = p;  
        hlist[hash_value].entry_count++;  
    }  
    hlist[hash_value].hit_count++;  
}  
 
void hashtest_init()  
{  
    int i;  
      
    hash_call_count = 0;  
    hlist = (struct hash_counter_entry *) malloc (sizeof(struct hash_counter_entry) *  backet_len);  
    if (NULL == hlist)  
    {  
        perror("malloc in hashtest_init");  
        return;  
    }  
    for (i = 0; i < backet_len; i++)  
    {  
        hlist[i].hit_count = 0;  
        hlist[i].entry_count = 0;  
        hlist[i].keys = NULL;  
    }  
}  
 
void hashtest_clean()  
{  
    int i;  
    struct hash_key *pentry, *p;  
 
    if (NULL == hlist)  
        return;  
 
    for (i = 0; i < backet_len; ++i)  
    {  
        pentry = hlist[i].keys;  
        while(pentry)  
        {  
            p = pentry->next;  
            if (pentry->key) free(pentry->key);  
            free(pentry);  
            pentry = p;  
        }  
    }  
    free(hlist);  
}  
 
void show_hashtest_result()  
{  
    int i, backet = 0, max_link = 0, sum = 0;  
    int conflict_count = 0, hit_count = 0;  
    float avg_link, backet_usage;  
 
    for(i = 0; i < backet_len; i++)  
    {  
        if (hlist[i].hit_count > 0)   
        {  
            backet++;  
            sum += hlist[i].entry_count;  
            if (hlist[i].entry_count > max_link)  
            {  
                max_link = hlist[i].entry_count;  
            }  
            if (hlist[i].entry_count > 1)  
            {  
                conflict_count++;  
            }  
            hit_count += hlist[i].hit_count;  
        }  
    }  
 
    backet_usage = backet/1.0/backet_len * 100;;  
    avg_link = sum/1.0/backet;  
 
    printf("backet_len = %d/n", backet_len);  
    printf("hash_call_count = %d/n", hash_call_count);  
    printf("hit_count = %d/n", hit_count);  
    printf("conflict count = %d/n", conflict_count);  
    printf("longest hash entry = %d/n", max_link);  
    printf("average hash entry length = %.2f/n", avg_link);  
    printf("backet usage = %.2f%/n", backet_usage);  
}  
 
void usage()  
{  
    printf("Usage: hashtest filename hash_func_name [backet_len]/n");  
    printf("hash_func_name:/n");  
    printf("/tsimple_hash/n");  
    printf("/tRS_hash/n");  
    printf("/tJS_hash/n");  
    printf("/tPJW_hash/n");  
    printf("/tELF_hash/n");  
    printf("/tBKDR_hash/n");  
    printf("/tSDBM_hash/n");  
    printf("/tDJB_hash/n");  
    printf("/tAP_hash/n");  
    printf("/tCRC_hash/n");  
}  
 
void md5_to_32(unsigned char *md5_16, unsigned char *md5_32)  
{  
    int i;  
 
    for (i = 0; i < 16; ++i)  
    {  
        sprintf(md5_32 + i * 2, "%02x", md5_16[i]);  
    }  
}  
 
int main(int argc, char *argv[])  
{  
    int fd = -1, rwsize = 0;  
    unsigned char md5_checksum[16 + 1] = {0};  
    unsigned char buf[BLOCK_LEN] = {0};  
 
    if (argc < 3)   
    {  
        usage();  
        return -1;  
    }  
 
    if (-1 == (fd = open(argv[1], O_RDONLY)))  
    {  
        perror("open source file");  
        return errno;  
    }  
 
    if (argc == 4)  
    {  
        backet_len = atoi(argv[3]);  
    }  
 
    hashtest_init();  
    choose_hash_func(argv[2]);  
    while (rwsize = read(fd, buf, BLOCK_LEN))  
    {  
        md5(buf, rwsize, md5_checksum);  
        insert_hash_entry(md5_checksum, hlist);  
        hash_call_count++;  
        memset(buf, 0, BLOCK_LEN);  
        memset(md5_checksum, 0, 16 + 1);  
    }  
    close(fd);  
 
    show_hashtest_result();  
    hashtest_clean();  
    return 0;  
} 



本文出处：http://blog.csdn.net/liuben/archive/2009/12/21/5050697.aspx

jackfirst86
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LintCode：哈希函数 · hash function
LIsmooth的博客
06-29 588
今天在LintCode上做了一道关于哈希函数的题目，感受到了数学思维在编程中的重要性，不多说，上题： 题目 在数据结构中，哈希函数是用来将一个字符串（或任何其他类型）转化为小于哈希表大小且大于等于零的整数。一个好的哈希函数可以尽可能少地产生冲突。一种广泛使用的哈希函数算法是使用数值33，假设任何字符串都是基于33的一个大整数，比如： hashcode(“abcd”) ...
哈希(Hash)与算法的衡量
chenchen_fcj程序猿的博客
03-29 426
对于map来说，背后就是平衡搜索二叉树，具体可见https://blog.csdn.net/weixin_42513339/article/details/88889306，空间复杂度为 O(logN) 对于unorder_map来说，背后就是哈希，空间复杂度为 O(1)，其中O(1)就是类似数组，给与下标就能快速找到。 什么是哈希？ 某度定义：散列表（Hash table，也叫哈希...
哈希表（散列）
weixin_45863060的博客
06-08 814
哈希表（散列） 定义 哈希表 哈希表（散列表）是一种将关键字key与地址或其它数据建立起直接映射关系的数据结构。哈希表通过哈希函数（hash函数）将关键字key进行运算并映射到散列表中的某一位置，建立起这样的映射关系可以加快对数据的查找和访问。 哈希函数 哈希函数的功能是建立其关键字key与哈希表中存储位置的映射关系。 将关键字按一定算法转换成数值，再对数值做一定处理得出hashcode，hashcode代表了数据对象在哈希表中存储的索引位置index。 一个好的hash函数应具备两个条件：尽可能地将数据
字符串的经典hash算法
横云断岭的专栏
09-29 1万+
字符串 hash 算法
常用的字符串哈希函数
dvlinker的技术专栏
01-23 1万+
本文将介绍什么是字符串哈希函数，字符串哈希函数常见用法，以及字符串哈希函数的实现原理和常用算法。
字符串哈希(BKDR_Hash)
日常记录，挨打要立正！
10-09 8707
详讲BKDR_Hash，并用C语言实现简版代码
字符串哈希
trudbot
09-08 1721
不难分析得到， 由于PQ是回文字符串， 则P中长度等于Q的前缀应该与Q成倒序关系， 设这个前缀为P1, P中除去P1的后半部分为P2。在上述哈希函数中， P选取为131(此质数在先人的实验中表现最好， 不容易发生冲突)， 而hashCode更是以幂级增长的， 因此很容易就溢出， 需要对其进行取模。，其中n为串长，与暴力匹配没有区别，如果需要多次询问一个字符串的子串的哈希值，每次重新计算效率非常低下。因此可以用两个字符串的。因此可以使用特别的哈希函数， 使用字符串前缀的哈希值而推出任一连续子串的哈希值。
【算法学习】字符串哈希（Hash）
热门推荐
Mikchy的博客
01-15 3万+
什么是字符串Hash 构造字符串Hash 1）自然溢出方法 2）单Hash方法 3）双Hash方法 4）三种不同的构造方法的对比 获取子串的Hash O(1) 1）例子 2）公式 具体的题目例子 1）题目链接 2）题意 3）解题分析 4）AC代码（自然溢出 C++） 5）AC代码（单Hash C++） 6）AC代码（双Hash C++） 什么是字符串Hash ...
字符串哈希函数
最新发布
2301_81731156的博客
04-14 1033
字符串哈希(BKDH-Hash)
经典字符串hash函数介绍及性能比较
djinglan的专栏
04-17 3万+
各种字符串Hash函数 http://www.cnblogs.com/atlantis13579/archive/2010/02/06/1664792.html http://blog.csdn.net/icefireelf/article/details/5796529 字符串Hash函数对比 分类： 数据结构与算法 2010-08-08 11:21 783人阅读 评论(0)收藏
常用字符串hash算法及评测
netqvq|求知
09-17 609
RS hash 算法 unsigned int RSHash(char* str, unsigned int len) {     unsigned int b    = 378551;     unsigned int a    = 63689;     unsigned int hash = 0;     unsigned int i    = 0;
[算法] 字符串 | 字符串哈希理论基础
emmmm.....
05-04 1610
字符串哈希简介、字符串哈希方法（自然溢出法、单哈希法、双哈希法）、字符串哈希值求解过程模拟、字符串子串的哈希值
字符串Hash函数
知行且执行
07-19 737
Hash函数：Hash，一般翻译做"散列"，也有直接音译为"哈希"的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。完美的h
138. 兔子与兔子（哈希）
tomjobs的博客
08-20 518
很久很久以前，森林里住着一群兔子。 有一天，兔子们想要研究自己的 DNA 序列。 我们首先选取一个好长好长的 DNA 序列（小兔子是外星生物，DNA 序列可能包含 26 个小写英文字母）。 然后我们每次选择两个区间，询问如果用两个区间里的 DNA 序列分别生产出来两只兔子，这两个兔子是否一模一样。 注意两个兔子一模一样只可能是他们的 DNA 序列一模一样。 输入格式 第一行输入一个 DNA 字符串...
字符串hash
二喵君的博客
10-21 3941
  这个是在学习哈希表的时候偶然带出来的，想着都是hash家的人，一起看看，结果比哈希表难好多【或许是哈希表学的不深入】；  解决问题：   字符串hash主要应用在：寻找长度为n的主串S中的匹配串T（长度为m）出现的位置或次数的问题属于字符串匹配问题。【将KMP一起看了，这种问题用KMP也可以解决啊，而且人家KMP的代码短啊，，也是不太清楚字符串hash存在的意义是啥，，】如果是从主串中每次...
CityHash: Google的高效字符串哈希算法
"CityHash是一种快速的字符串哈希函数，由Google的Geoff Pike和Jyrki Alakuijala合作开发。它被设计用于高效地处理字符串数据，提供高质量的哈希值，以用于数据索引、一致性检查等场景。CityHash的主要目标是速度和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值