Implementation of several classic Hash Algorithms in open-source software

Http://zh.wikipedia.org/wiki/%E5%93%88%E5%B8%8C%E8%A1%A8

Http://en.wikipedia.org/wiki/Hash_table

 

The hash algorithm maps binary values of any length to smaller binary values of a fixed length. This smaller binary value is called a hash value. A hash value is a unique and extremely compact numeric representation of a piece of data. If a piece of plain text is hashed and only one letter of the paragraph is modified, the subsequent hash will generate different values. It is impossible to calculate two different inputs with the same hash value. Therefore, the hash value of the data can be used to check the integrity of the data.

 

 

The time efficiency of the linked list query is O (n), the binary method is log2n, and the B + tree is log2n, but the time efficiency of the hash linked list query is O (1 ).

To design efficient algorithms, hash linked lists are often used. Constant-level search speeds are incomparable to any other algorithms. The construction and conflicting implementation methods of hash linked lists certainly have a certain impact on efficiency, however, the hash function is the core part of the hash linked list. below is the implementation of the string hash function used in several classic software. By reading these codes, we can have a deep understanding of hash algorithm execution efficiency, discretization, and space utilization.

The following describes the string hash functions in the classic software.

● String hash function in PHP

static unsigned long hashpjw(char *arKey, unsigned int nKeyLength){      unsigned long h = 0, g;       char *arEnd=arKey+nKeyLength; while (arKey < arEnd) {h = (h << 4) + *arKey++;if ((g = (h & 0xF0000000))) {h = h ^ (g >> 24);h = h ^ g;}}return h;}
●String hash function in OpenSSL
unsigned long lh_strhash(char *str){int i,l;unsigned long ret=0;unsigned short *s; if (str == NULL) return(0);l=(strlen(str)+1)/2;s=(unsigned short *)str; for (i=0; iret^=(s[i]<<(i&0x0f));return(ret);} 
/* The following hash seems to work very well on normal text strings * no collisions on/usr/dict/words and it distributes on % 2 ^ n quite * Well, not as good as MD5, but still good. */
unsigned long lh_strhash(const char *c){unsigned long ret=0;long n;unsigned long v;int r; if ((c == NULL) || (*c == '\0'))return(ret);/*unsigned char b[16]; MD5(c,strlen(c),b); return(b[0]|(b[1]<<8)|(b[2]<<16)|(b[3]<<24)); */ n=0x100;while (*c){v=n|(*c);n+=0x100;r= (int)((v>>2)^v)&0x0f;ret=(ret(32-r));ret&=0xFFFFFFFFL;ret^=v*v;c++;} return((ret>>16)^ret);}
●String hash function in MySQL
#ifndef NEW_HASH_FUNCTION /* Calc hashvalue for a key */static uint calc_hashnr(const byte *key,uint length){register uint nr=1, nr2=4; while (length--){nr^= (((nr & 63)+nr2)*((uint) (uchar) *key++))+ (nr << 8);nr2+=3;} return((uint) nr);} /* Calc hashvalue for a key, case indepenently */static uint calc_hashnr_caseup(const byte *key,uint length){register uint nr=1, nr2=4; while (length--){nr^= (((nr & 63)+nr2)*((uint) (uchar) toupper(*key++)))+ (nr << 8);nr2+=3;} return((uint) nr);}#else/* 
* Fowler/Noll/Vo hash * * The basis of the hash algorithm was taken from an idea sent by email to the * IEEE Posix P1003.2 mailing list from Phong Vo (kpv@research.att.com) and * Glenn Fowler (gsf@research.att.com). Landon Curt Noll (chongo@toad.com) * later improved on their algorithm. * * The magic is in the interesting relationship between the special prime * 16777619 (2^24 + 403) and 2^32 and 2^8. * * This hash produces the fewest collisions of any function that we've seen so * far, and works well on both numbers and strings. */uint calc_hashnr(const byte *key, uint len){const byte *end=key+len;uint hash; for (hash = 0; key < end; key++){hash *= 16777619;hash ^= (uint) *(uchar*) key;} return (hash);} uint calc_hashnr_caseup(const byte *key, uint len){const byte *end=key+len;uint hash; for (hash = 0; key < end; key++){hash *= 16777619;hash ^= (uint) (uchar) toupper(*key);} return (hash);}#endif
The string hash function in MySQL is also case sensitive.
●Another hash function of the classic string
unsigned int hash(char *str){register unsigned int h;register unsigned char *p; for(h=0, p = (unsigned char *)str; *p ; p++)h = 31 * h + *p; return h;}
 
Asterisk Server
/*! * \brief Compute a hash value on a case-insensitive string * * Uses the same hash algorithm as ast_str_hash, but converts * all characters to lowercase prior to computing a hash. This * allows for easy case-insensitive lookups in a hash table. */static force_inline int attribute_pure ast_str_case_hash(const char *str){ int hash = 5381; while (*str) {  hash = hash * 33 ^ tolower(*str++); } return abs(hash);}