[转]libhash中的哈希函数

随便贴一个libhash中的hash函数，写的貌似不错，贴出来玩玩。

hash.h

/*
 * Australian Public Licence B (OZPLB)
 * 
 * Version 1-0
 * 
 * Copyright (c) 2004 National ICT Australia
 * 
 * All rights reserved. 
 * 
 * Developed by: Embedded, Real-time and Operating Systems Program (ERTOS)
 *               National ICT Australia
 *                http://www.ertos.nicta.com.au
  */

#ifndef _HASH_H
#define  _HASH_H

#include  < stdint.h >

struct  hashtable {
         struct  hashentry  ** table;
        unsigned  int  size;
         struct  hashentry  * spares;
};
    
struct  hashentry {
         struct  hashentry  * next;
        uintptr_t key;
         void   * value;
};

struct  hashtable  * hash_init (unsigned  int  size);
void  hash_free ( struct  hashtable  * tablestruct);
uintptr_t hash_hash(uintptr_t key);
void   * hash_lookup ( struct  hashtable  * tablestruct, uintptr_t key);
int  hash_insert ( struct  hashtable  * tablestruct, uintptr_t key,  void   * value);
void  hash_remove ( struct  hashtable  * tablestruct, uintptr_t key);

#endif  /* !_HASH_H */

 

hash.c

#include  < stdint.h >
#include  < stdlib.h >
#include  < assert.h >

#include  " hash.h "

struct  hashtable  *
hash_init (unsigned  int  size)
{
         struct  hashtable  * tablestruct;
         int  counter;

         /*  Our hash function only works with power-of-2 bucket sizes for speed.  */
        assert ((size  &  (size  - 1 ))  ==   0 );

        tablestruct  =  malloc ( sizeof  ( struct  hashtable)); assert (tablestruct);
         if  ( ! tablestruct) {
                 return  NULL;
        }
        tablestruct -> table  =  malloc (size  *   sizeof  ( struct  hashentry  * ));
         if  ( ! tablestruct -> table) {
                 return  NULL;
        }
         for  (counter = 0 ; counter < size; counter ++ ) {
                tablestruct -> table[counter]  =  NULL;
        }
        assert (tablestruct -> table);
        tablestruct -> size  =  size;
        tablestruct -> spares  =  NULL;

         return  tablestruct;
}

/*  Ref  http://www.concentric.net/ ~Ttwang/tech/inthash.htm  */
uintptr_t
hash_hash(uintptr_t key)
{
#if  (UINTPTR_MAX == UINT32_MAX)
        key  +=   ~ (key  <<   15 );
        key  ^=   (key  >>   10 );
        key  +=   (key  <<   3 );
        key  ^=   (key  >>   6 );
        key  +=   ~ (key  <<   11 );
        key  ^=   (key  >>   16 );
#elif  (UINTPTR_MAX == UINT64_MAX)
        key  +=   ~ (key  <<   32 );
        key  ^=  (key  >>   22 );
        key  +=   ~ (key  <<   13 );
        key  ^=  (key  >>   8 );
        key  +=  (key  <<   3 );
        key  ^=  (key  >>   15 );
        key  +=   ~ (key  <<   27 );
        key  ^=  (key  >>   31 );
#else
#error  unsupported word size
#endif
         // printf ("new key is %d ", key);
         return  key;
}

void   *
hash_lookup ( struct  hashtable  * tablestruct, uintptr_t key)
{
        uintptr_t hash;
         struct  hashentry  * entry;

        hash  =  hash_hash (key)  &  (tablestruct -> size  -   1 );
         for  (entry  =  tablestruct -> table[hash]; entry  !=  NULL; entry  =  entry -> next) {
                 if  (entry -> key  ==  key) {
                         return  entry -> value;
                }
        }
         return  NULL;
}

/*  Add the key to the hash table. Assumes the key is not already present.  */
int
hash_insert ( struct  hashtable  * tablestruct, uintptr_t key,  void   * value)
{
        uintptr_t hash;
         struct  hashentry  * entry;

        hash  =  hash_hash (key)  &  (tablestruct -> size  -   1 );
         // printf ("bucket is %d ", hash);

        entry  =  malloc ( sizeof  ( struct  hashentry));
         if  ( ! entry) {
                 return   - 1 ;
        }
        entry -> key  =  key;
        entry -> value  =  value;
        entry -> next  =  tablestruct -> table[hash];

        tablestruct -> table[hash]  =  entry;
         return   0 ;
}

/*  Removes the key from the hash table. Does not signal an error if the key
 * was not present.  */
void
hash_remove ( struct  hashtable  * tablestruct, uintptr_t key)
{
        uintptr_t hash;
         struct  hashentry  * entry,  * tmpentry;

        hash  =  hash_hash (key)  &  (tablestruct -> size  -   1 );
        entry  =  tablestruct -> table[hash];
         /*  If this is the first entry then it needs special handling.  */
         if  (entry  &&  entry -> key  ==  key) {
                tmpentry  =  entry -> next;
                free (entry);
                tablestruct -> table[hash]  =  tmpentry;
        }  else  {
                 while  (entry) {
                         if  (entry -> next  &&  entry -> next -> key  ==  key) {
                                tmpentry  =  entry -> next;
                                entry -> next  =  entry -> next -> next;
                                free (tmpentry);
                                 break ;
                        }
                        entry  =  entry -> next;
                }
        }
}

 

hash_free.c

#include  < stdint.h >
#include  < stdlib.h >

#include  " hash.h "

void
hash_free ( struct  hashtable  * tablestruct)
{
         int  counter;
         struct  hashentry  * entry,  * prev;

         /*  Need to free buckets and table struct and every item in every chain  */
         for  (counter = 0 ; counter < tablestruct -> size; counter ++ ) {
                entry  =  tablestruct -> table[counter];
                 while  (entry) {
                        prev  =  entry;
                        entry  =  entry -> next;
                        free (prev);
                }
        }
        free (tablestruct -> table);
        free (tablestruct);
}

 

来源：http://ertos.nicta.com.au/software/kenge/libhash/devel/

更多结果：http://www.google.cn/search?complete=1&hl=zh-CN&q=libhash&meta=