一个开源的哈希表源码实现

 

struct  entry
... {
    void *k, *v;
    unsigned int h;
    struct entry *next;
} ;

struct  hashtable  ... {
    unsigned int tablelength;
    struct entry **table;
    unsigned int entrycount;
    unsigned int loadlimit;
    unsigned int primeindex;
    unsigned int (*hashfn) (void *k);
    int (*eqfn) (void *k1, void *k2);
} ;

static   const  unsigned  int  primes[]  =   ... {
    53, 97, 193, 389, 769, 1543, 3079, 6151,
    12289, 24593, 49157, 98317,
    196613, 393241, 786433, 1572869,
    3145739, 6291469, 12582917, 25165843,
    50331653, 100663319, 201326611, 402653189,
    805306457, 1610612741
} ;

const  unsigned  int  prime_table_length  =   sizeof (primes) / sizeof (primes[ 0 ]);
const   float  max_load_factor                  =   0.65 ;

struct  hashtable  * create_hashtable(unsigned  int  minsize,
                                                             unsigned  int  ( * hashf) (  struct  hashtable  * ,  void *  ),
                                                             int  ( * eqf) ( void * , void * ))
... {
    struct hashtable *h;
    unsigned int pindex, size = primes[0];
    
    /**//* Check requested hashtable isn't too large */
    if (minsize > (1u << 30)) 
                   return  NULL;
    /**//* Enforce size as prime */
    for (pindex=0; pindex < prime_table_length; pindex++) 
    ...{
                  if (primes[pindex] > minsize) 
             ...{
                                 size = primes[pindex]; 
                                  break; 
                 }
           }
     h = (struct hashtable *)malloc(sizeof(struct hashtable));
     if (NULL == h) 
           return NULL; /**//*oom*/

    h->table = (struct entry **)malloc(sizeof(struct entry*) * size);
    if (NULL == h->table)
    ...{ 
                  free(h); 
                    return NULL; 
    } /**//*oom*/
    memset(h->table, 0, size * sizeof(struct entry *));

    h->tablelength  = size;
    h->primeindex   = pindex;
    h->entrycount   = 0;
    h->hashfn       = hashf;
    h->eqfn         = eqf;
    h->loadlimit    = (unsigned int) ceil(size * max_load_factor);
    
    return h;
}

unsigned  int  hash( struct  hashtable  * h,  void   * k)
... {
    /**//* Aim to protect against poor hash functions by adding logic here 
    - logic taken from java 1.4 hashtable source */
    unsigned int i = h->hashfn(k);
         i += ~(i << 9);
    i ^=  ((i >> 14) | (i << 18)); /**//* >>> */
          i +=  (i << 4);
    i ^=  ((i >> 10) | (i << 22)); /**//* >>> */
    return i;
}