字符串Hash函数

最新推荐文章于 2024-07-22 08:00:00 发布
最新推荐文章于 2024-07-22 08:00:00 发布
阅读量1.3k 收藏 2
点赞数
分类专栏： C++ && MFC 文章标签： function conflict struct null insert 测试

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_hash1024047198164.6399.00%
RS_hash1024047198164.6398.91%
JS_hash1024047198154.6498.87%
PJW_hash1024047198164.6399.00%
ELF_hash1024047198164.6399.00%
BKDR_hash1024047198164.6399.00%
SDBM_hash1024047198164.6398.90%
DJB_hash1024047198154.6498.85%
AP_hash1024047198164.6398.96%
CRC_hash1024047198164.6498.77%

附录源代码：

hash.h

 

  1. #ifndef _HASH_H 
  2. #define _HASH_H 
  3.  
  4. #ifdef __cplusplus 
  5. extern "C" { 
  6. #endif 
  7.  
  8. /* A Simple Hash Function */ 
  9. unsigned int simple_hash(char *str); 
  10.  
  11. /* RS Hash Function */ 
  12. unsigned int RS_hash(char *str); 
  13.  
  14. /* JS Hash Function */ 
  15. unsigned int JS_hash(char *str); 
  16.  
  17. /* P. J. Weinberger Hash Function */ 
  18. unsigned int PJW_hash(char *str); 
  19.  
  20. /* ELF Hash Function */ 
  21. unsigned int ELF_hash(char *str); 
  22.  
  23. /* BKDR Hash Function */ 
  24. unsigned int BKDR_hash(char *str); 
  25.  
  26. /* SDBM Hash Function */ 
  27. unsigned int SDBM_hash(char *str); 
  28.  
  29. /* DJB Hash Function */ 
  30. unsigned int DJB_hash(char *str); 
  31.  
  32. /* AP Hash Function */ 
  33. unsigned int AP_hash(char *str); 
  34.  
  35. /* CRC Hash Function */ 
  36. unsigned int CRC_hash(char *str); 
  37.  
  38. #ifdef __cplusplus 
  39. } 
  40. #endif 
  41.  
  42. #endif 

 

hash.c

  • #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

     

    1. #include <stdio.h> 
    2. #include <stdlib.h> 
    3. #include <sys/types.h> 
    4. #include <sys/stat.h> 
    5. #include <fcntl.h> 
    6. #include <errno.h> 
    7. #include <string.h> 
    8. #include "hash.h" 
    9. #include "md5.h" 
    10. struct hash_key { 
    11.     unsigned char *key; 
    12.     struct hash_key *next;  
    13. }; 
    14. struct hash_counter_entry { 
    15.     unsigned int hit_count; 
    16.     unsigned int entry_count; 
    17.     struct hash_key *keys; 
    18. }; 
    19. #define BLOCK_LEN   4096 
    20. static int backet_len = 10240; 
    21. static int hash_call_count = 0; 
    22. static struct hash_counter_entry *hlist = NULL; 
    23. unsigned int (*hash_func)(char *str); 
    24. void choose_hash_func(char *hash_func_name) 
    25. { 
    26.     if (0 == strcmp(hash_func_name, "simple_hash")) 
    27.         hash_func = simple_hash; 
    28.     else if (0 == strcmp(hash_func_name, "RS_hash")) 
    29.         hash_func = RS_hash; 
    30.     else if (0 == strcmp(hash_func_name, "JS_hash")) 
    31.         hash_func = JS_hash; 
    32.     else if (0 == strcmp(hash_func_name, "PJW_hash")) 
    33.         hash_func = PJW_hash; 
    34.     else if (0 == strcmp(hash_func_name, "ELF_hash")) 
    35.         hash_func = ELF_hash; 
    36.     else if (0 == strcmp(hash_func_name, "BKDR_hash")) 
    37.         hash_func = BKDR_hash; 
    38.     else if (0 == strcmp(hash_func_name, "SDBM_hash")) 
    39.         hash_func = SDBM_hash; 
    40.     else if (0 == strcmp(hash_func_name, "DJB_hash")) 
    41.         hash_func = DJB_hash; 
    42.     else if (0 == strcmp(hash_func_name, "AP_hash")) 
    43.         hash_func = AP_hash; 
    44.     else if (0 == strcmp(hash_func_name, "CRC_hash")) 
    45.         hash_func = CRC_hash; 
    46.     else 
    47.         hash_func = NULL; 
    48. } 
    49. void insert_hash_entry(unsigned char *key, struct hash_counter_entry *hlist) 
    50. { 
    51.     unsigned int hash_value = hash_func(key) % backet_len; 
    52.     struct hash_key *p; 
    53.     p = hlist[hash_value].keys; 
    54.     while(p) { 
    55.         if (0 == strcmp(key, p->key)) 
    56.             break; 
    57.         p = p->next; 
    58.     } 
    59.     if (p == NULL) 
    60.     { 
    61.         p = (struct hash_key *)malloc(sizeof(struct hash_key)); 
    62.         if (p == NULL)  
    63.         { 
    64.             perror("malloc in insert_hash_entry"); 
    65.             return; 
    66.         } 
    67.         p->key = strdup(key); 
    68.         p->next = hlist[hash_value].keys; 
    69.         hlist[hash_value].keys = p; 
    70.         hlist[hash_value].entry_count++; 
    71.     } 
    72.     hlist[hash_value].hit_count++; 
    73. } 
    74. void hashtest_init() 
    75. { 
    76.     int i; 
    77.     hash_call_count = 0; 
    78.     hlist = (struct hash_counter_entry *) malloc (sizeof(struct hash_counter_entry) *  backet_len); 
    79.     if (NULL == hlist) 
    80.     { 
    81.         perror("malloc in hashtest_init"); 
    82.         return; 
    83.     } 
    84.     for (i = 0; i < backet_len; i++) 
    85.     { 
    86.         hlist[i].hit_count = 0; 
    87.         hlist[i].entry_count = 0; 
    88.         hlist[i].keys = NULL; 
    89.     } 
    90. } 
    91. void hashtest_clean() 
    92. { 
    93.     int i; 
    94.     struct hash_key *pentry, *p; 
    95.     if (NULL == hlist) 
    96.         return; 
    97.     for (i = 0; i < backet_len; ++i) 
    98.     { 
    99.         pentry = hlist[i].keys; 
    100.         while(pentry) 
    101.         { 
    102.             p = pentry->next; 
    103.             if (pentry->key) free(pentry->key); 
    104.             free(pentry); 
    105.             pentry = p; 
    106.         } 
    107.     } 
    108.     free(hlist); 
    109. } 
    110. void show_hashtest_result() 
    111. { 
    112.     int i, backet = 0, max_link = 0, sum = 0; 
    113.     int conflict_count = 0, hit_count = 0; 
    114.     float avg_link, backet_usage; 
    115.     for(i = 0; i < backet_len; i++) 
    116.     { 
    117.         if (hlist[i].hit_count > 0)  
    118.         { 
    119.             backet++; 
    120.             sum += hlist[i].entry_count; 
    121.             if (hlist[i].entry_count > max_link) 
    122.             { 
    123.                 max_link = hlist[i].entry_count; 
    124.             } 
    125.             if (hlist[i].entry_count > 1) 
    126.             { 
    127.                 conflict_count++; 
    128.             } 
    129.             hit_count += hlist[i].hit_count; 
    130.         } 
    131.     } 
    132.     backet_usage = backet/1.0/backet_len * 100;; 
    133.     avg_link = sum/1.0/backet; 
    134.     printf("backet_len = %d/n", backet_len); 
    135.     printf("hash_call_count = %d/n", hash_call_count); 
    136.     printf("hit_count = %d/n", hit_count); 
    137.     printf("conflict count = %d/n", conflict_count); 
    138.     printf("longest hash entry = %d/n", max_link); 
    139.     printf("average hash entry length = %.2f/n", avg_link); 
    140.     printf("backet usage = %.2f%/n", backet_usage); 
    141. } 
    142. void usage() 
    143. { 
    144.     printf("Usage: hashtest filename hash_func_name [backet_len]/n"); 
    145.     printf("hash_func_name:/n"); 
    146.     printf("/tsimple_hash/n"); 
    147.     printf("/tRS_hash/n"); 
    148.     printf("/tJS_hash/n"); 
    149.     printf("/tPJW_hash/n"); 
    150.     printf("/tELF_hash/n"); 
    151.     printf("/tBKDR_hash/n"); 
    152.     printf("/tSDBM_hash/n"); 
    153.     printf("/tDJB_hash/n"); 
    154.     printf("/tAP_hash/n"); 
    155.     printf("/tCRC_hash/n"); 
    156. } 
    157. void md5_to_32(unsigned char *md5_16, unsigned char *md5_32) 
    158. { 
    159.     int i; 
    160.     for (i = 0; i < 16; ++i) 
    161.     { 
    162.         sprintf(md5_32 + i * 2, "%02x", md5_16[i]); 
    163.     } 
    164. } 
    165. int main(int argc, char *argv[]) 
    166. { 
    167.     int fd = -1, rwsize = 0; 
    168.     unsigned char md5_checksum[16 + 1] = {0}; 
    169.     unsigned char buf[BLOCK_LEN] = {0}; 
    170.     if (argc < 3)  
    171.     { 
    172.         usage(); 
    173.         return -1; 
    174.     } 
    175.     if (-1 == (fd = open(argv[1], O_RDONLY))) 
    176.     { 
    177.         perror("open source file"); 
    178.         return errno; 
    179.     } 
    180.     if (argc == 4) 
    181.     { 
    182.         backet_len = atoi(argv[3]); 
    183.     } 
    184.     hashtest_init(); 
    185.     choose_hash_func(argv[2]); 
    186.     while (rwsize = read(fd, buf, BLOCK_LEN)) 
    187.     { 
    188.         md5(buf, rwsize, md5_checksum); 
    189.         insert_hash_entry(md5_checksum, hlist); 
    190.         hash_call_count++; 
    191.         memset(buf, 0, BLOCK_LEN); 
    192.         memset(md5_checksum, 0, 16 + 1); 
    193.     } 
    194.     close(fd); 
    195.     show_hashtest_result(); 
    196.     hashtest_clean(); 
    197.     return 0; 
    198. } 

     

     

    原文地址：http://blog.youkuaiyun.com/liuben/article/details/5050697

常用的字符串哈希函数
dvlinker的技术专栏
01-23 1万+
本文将介绍什么是字符串哈希函数，字符串哈希函数常见用法，以及字符串哈希函数的实现原理和常用算法。
c语言字符串计算哈希值,【C语言】哈希函数写法、字符串深度复制
weixin_39612058的博客
05-17 1673
Little trick.html1 哈希函数理想的哈希函数保证每一个字符串对应惟一的哈希值。下面这个哈希函数是同窗在项目中遇到的。算法unsigned int hash(char* s){unsigned int h=0;for(;*s;s++)h = *s + h*31;return h%HASHSIZE; //predefined hash size}能够看出，这个hash函数遍历字符串中每...
用C语言实现常用的字符串哈希函数
01-12
用C语言实现常用的字符串哈希函数，比如RSHash、JSHash、PJWHash、FNVHash等
字符串Hash函数评估
热门推荐
刘爱贵的专栏
12-21 2万+
Hash查找因为其O(1)的查找性能而著称，被对查找性能要求高的应用所广泛采用。它的基本思想是：(1) 创建一个定长的线性Hash表，一般可以初始化时指定length;(2) 设计Hash函数，将关键字key散射到Hash表中。其中hash函数设计是最为关键的，均匀分布、冲突概率小全在它；(3) 通常采用拉链方法来解决hash冲突问题，即散射到同一个hash表项的关键字，以链表形式来表示(
hash函数
uiiの技术随笔
03-08 631
转载自：http://blog.youkuaiyun.com/cnnumen/article/details/5777643 所有内容均来自于：http://www.partow.net/programming/hashfunctions/ 以下总共给出了10种字符串hash函数，在上面的链接中可以找到各个Hash函数的描述，以及一些其它的关于hash函数的资料下载。 这些hash函数各自的优缺点不详。
哈希(Hash)与算法的衡量
chenchen_fcj程序猿的博客
03-29 515
对于map来说，背后就是平衡搜索二叉树，具体可见https://blog.youkuaiyun.com/weixin_42513339/article/details/88889306，空间复杂度为 O(logN) 对于unorder_map来说，背后就是哈希，空间复杂度为 O(1)，其中O(1)就是类似数组，给与下标就能快速找到。 什么是哈希？ 某度定义：散列表（Hash table，也叫哈希...
常用hash函数介绍
梦之音的专栏
06-07 3043
unsigned int SDBMHash(char *str) { unsigned int hash = 0; while (*str) { // equivalent to: hash = 65599*hash + (*str++); hash = (*str++) + (hash } return (hash & 0x7FFFFFFF); }
字符串Hash
01-20
字符串Hash函数把一个任意长度的字符串映射成一个非负整数，并且其冲突概率几乎为 000。 取一固定值 PPP，把字符串看作 PPP 进制数，并分配一个大于 000 的数值，代表每种字符。一般来说，我们分配的数值都远小于P。...
各种字符串Hash函数比较1
08-08
标题提到的"各种字符串Hash函数比较1"是一个关于评估不同字符串哈希函数性能的文章。描述中提到了一些常见的哈希函数，如BKDRHash、APHash、DJBHash、JSHash、RSHash、SDBMHash、PJWHash和ELFHash，并且给出了这些...
经典字符串hash函数
09-01
在计算机科学中，字符串哈希（Hash）函数是一种将任意长度的字符串映射为固定长度数值的方法，这个数值通常称为哈希值。哈希函数在数据结构、算法和信息安全等领域有着广泛的应用，如散列表的构建、快速查找、数据...
hash函数的设计优化
05-26
主要是关于hansh函数的设计优化，希望对大家有所帮助
哈希函数
weixin_45346719的博客
05-12 280
关于哈希函数 哈希函数 一种函数H，根据这个函数和查找关键字key，可以直接确定查找值所在位置，这个函数就是哈希函数，而哈希表是基于哈希函数建立的一种查找表 哈希冲突 对应不同的关键字（数值）可能获得相同的hash地址 哈希冲突解决办法 链地址法：为每个哈希值维护一个链表，并将具有相同哈希值的元素都放入这一链表当中。 如下图 开放地址法：当发现哈希值 hh 处产生冲突时，根据某种策略，从 hh 出发找到下一个不冲突的位置。例如，一种最简单的策略是，不断地检查 h+1,h+2,h+3,\ldotsh+1,
LintCode：哈希函数 · hash function
LIsmooth的博客
06-29 646
今天在LintCode上做了一道关于哈希函数的题目，感受到了数学思维在编程中的重要性，不多说，上题： 题目 在数据结构中，哈希函数是用来将一个字符串（或任何其他类型）转化为小于哈希表大小且大于等于零的整数。一个好的哈希函数可以尽可能少地产生冲突。一种广泛使用的哈希函数算法是使用数值33，假设任何字符串都是基于33的一个大整数，比如： hashcode(“abcd”) ...
10个经典的字符串hash函数的C代码实现
qq_43668159的博客
01-16 1752
10个经典的字符串hash函数的C代码实现
3、hash 函数的设计
沿海奔跑的少年
11-05 5703
1、hash 函数对整数和大整数的处理   对于整数的hash函数，我们设计hash 函数，我们可以用取模的方式来获得。 2、对于浮点型 设计hash 函数处理 3、对于字符串hash 函数的处理   4、对于复合类型的处理   5、我们设计哈希函数的原则？  ...
【C++高阶】哈希函数底层原理探索：从算法设计到实现优化
最新发布
EterNity_TiMe_的计算机学习之路
07-22 2238
在数字世界的浩瀚宇宙中，哈希算法如同星辰般璀璨，以其独特的方式照亮了数据处理与信息安全的道路。它们不仅是现代计算体系中的基石，更是连接数据安全、高效检索与分布式系统的桥梁。然而，当我们谈论哈希时，往往更多地聚焦于其上层应用与宏观效果，而忽视了支撑这些奇迹的底层机制与实现细节
哈希(Hash)函数(均匀Hash)
05-16 4526
[linux 2.4.0 -&amp;amp;amp;amp;gt; catalog.c] /* Number of hash table slots */ #define C_HASHBITS 10 #define C_HASHSIZE (1UL &amp;amp;amp;amp;lt;&amp;amp;amp;amp;lt; C_HASHBITS) #define C_HASHMASK (C_HASHSIZE - 1) /* * hashfn() * hash
负载均衡算法（一致性Hash算法，通俗易懂）
半山腰太挤了，你要去山顶看看
07-12 2376
一点感想 自从实习后很久没有写过文章了，不知不觉来阿里已经一周多了，还是感觉自己比较幸运能够拿到心仪的大厂实习，大厂的福利也对我们这样异地他乡的人提供了许多温暖（小声bb：大厂真不缺钱啊），刚开始每天心情极度焦虑低迷，还好有一群小伙伴每天都可以电话畅聊，抱团取暖，让每天平平淡淡的日子多了几分热闹，我们当初的努力可以让我们以后有更多选择的权利，进阿里是我进大学以来的梦想和目标，一个渣本大学生鬼知道经历了什么，但现在已是过去式了，离自己的人生目标还很远，我们每个人都不希望自己一生碌碌无为，铁子你也是吧；有的人想
字符串Hash函数分析与测试
"经典字符串Hash函数测试" 在计算机科学中，哈希函数是将任意长度的输入（也叫做键，key）转化为固定长度的输出，这个输出通常被称为哈希值或散列。在字符串处理和数据存储中，哈希函数扮演着重要的角色，特别是在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值