哈希表心得

出自陈皓博客《哈希表心得》，
链接：http://blog.csdn.net/haoel/article/details/2863

我们知道，哈希表是一个固定大小的数组，数组的每个元素是一个链表（单向或双向）的头指针。如果$Key$一样，则在一起，如果$Key$不一样，则不在一起。哈希表的查询是飞快的。因为它不需要从头搜索，它利用$Key$的“哈希算法”直接定位，查找非常快，各种数据库中的数据结构基本都是它。但带来的问题是，哈希表的尺寸、哈希算法。

哈希表的数组是定长的，如果太大，则浪费，如果太小，体现不出效率。合适的数组大小是哈希表的性能的关键。哈希表的尺寸最好是一个质数，最小的质数尺寸是$17$。

当然，根据不同的数据量，会有不同的哈希表的大小。对于数据量时多时少的应用，最好的设计是使用动态可变尺寸的哈希表，那么如果你发现哈希表尺寸太小了，比如其中的元素是哈希表尺寸的$2$倍时，我们就需要扩大哈希表尺寸，一般是扩大一倍。下面的数库是哈希表变化尺寸时尺寸大小的一个列表。

static int prime_array[] = {
    17,             /* 0 */
    37,             /* 1 */
    79,             /* 2 */
    163,            /* 3 */
    331,            /* 4 */
    673,            /* 5 */
    1361,           /* 6 */
    2729,           /* 7 */
    5471,           /* 8 */
    10949,          /* 9 */
    21911,          /* 10 */
    43853,          /* 11 */
    87719,          /* 12 */
    175447,         /* 13 */
    350899,         /* 14 */
    701819,         /* 15 */
    1403641,        /* 16 */
    2807303,        /* 17 */
    5614657,        /* 18 */
    11229331,       /* 19 */
    22458671,       /* 20 */
    44917381,       /* 21 */
    89834777,       /* 22 */
    179669557,      /* 23 */
    359339171,      /* 24 */
    718678369,      /* 25 */
    1437356741,     /* 26 */
    2147483647      /* 27 (largest signed int prime) */
};               

#define PRIME_ARRAY_SIZE  (28)

要使用哈希表，就一定要用一个哈希算法，来确定$KEY$值，这似乎是个很难的事，下面是一个哈希算法：

typedef struct _hTab{
    hLinks* link;    /* 一个链表 */
    int  num;     /* 成员个数 */
    int  size;    /* 表的尺寸 */
} hTab;

static unsigned int
getHashIndex(hTab *tabPtr, const char *key)
{
    unsigned int ha = 0;
   
    while (*key)
        ha = (ha * 128 + *key++) % tabPtr->size;

    return ha;

}

（其中$key$是一个字符串，$hTab$就是一个哈希表结构, $tabPtr->size$是哈希表数组的大小）

---

对比$STL$哈希表变化尺寸：

static const int __stl_num_primes = 28;
static const unsigned long __stl_prime_list[__stl_num_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,
	16110612741,	3221225473ul,	4294967291ul
};

对比$STL$哈希算法：

template <class Key> struct hash{}
inline size_t __stl_hash_string(const char* s)
{
	unsigned long h  = 0;
	for (; *s; ++s)
		h = 5*h + *s;
	return size_t(h);
}

template <>
__STL_TEMPLATE_NULL struct hash<char*>
{
	size_t operator()(const char *s)  const { return __stl_hash_string(s); }
};

我们可以发现大神博客的哈希表实现方式与$STL$并无二异，只是更换了$hash$表尺寸大小的取值及哈希算法；由于没有确切的实际数据对其进行检验，无法得出两者取值哪个更具效率，不过最主要的是理解为什么设计多个hash表尺寸以及理解$hash$算法，理解了这两点才是设计实现一个$hash$表最重要的内容。