写了个HashTable的模板类， 因为C++不是很专业所以写的有点挫， 模仿SGI STL的HashTable写的。
SGI STL用的vector， 我木有用， 主要是想锻炼下。~
在数据增长到千万级的时候，内存占用居然达到了坑爹的1.2G， 我一直以为是内存泄露，结果实测以后发现确实就是要占用这么多空间~。。
希望能找到什么优化方法。~
模板类：
/************************************************************************
* @file : HashTable.h
* @author : kevin <zhangtaopy-kevin@hotmail.com>
* @date : 2012/9/6 9:52:25
* @brief :
*
* $Id: $
/************************************************************************/
#ifndef __HASHTABLE_H__
#define __HASHTABLE_H__
#include <stdlib.h>
#include <memory.h>
#include <Windows.h>
// -------------------------------------------------------------------------
static const int number_of_primes = 28;
static const unsigned long prime_list[number_of_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, 3221225473ul, 4294967291ul
};
template <class Value>
struct __hash_node
{
__hash_node* next;
Value val;
};
template <class Value, class Hashfunc, class EqualKey>
class HashTable
{
public:
typedef Hashfunc hasher;
typedef EqualKey key_equal;
typedef __hash_node<Value> node;
public:
~HashTable();
HashTable(unsigned long ulSize);
HashTable(unsigned long ulSize, const Hashfunc& hf, const EqualKey& eq);
void init_bucket(unsigned long ulSize);
void resize(bool isUnique);
int insert_unique(const Value& obj);
int insert_equal(const Value& obj);
int insert_unique_noresize(const Value& obj);
int insert_equal_noresize(const Value& obj);
int find(const Value& obj);
private:
unsigned long m_ulFullSize;
unsigned long m_ulCurSize;
hasher m_hash;
key_equal m_equals;
node** m_bucket;
};
unsigned long LowerBound(const unsigned long* primelist, int n, unsigned long key)
{
int start = 0;
int end = n-1;
if(n == 0)
return -1;
while(start <= end)
{
int mid = (end - start)/2 + start;
if(key > primelist[mid])
{
start = mid + 1;
}
else if(key < primelist[mid])
{
end = mid - 1;
}
else
{
return primelist[mid];
}
}
if(end != n-1)
return primelist[end+1];
else
return primelist[n];
}
template <class V, class Hf, class Eq>
HashTable<V,Hf,Eq>::HashTable(unsigned long ulSize, const Hf& hf, const Eq& eq):m_ulCurSize(0),m_bucket(NULL),m_ulFullSize(0)
{
init_bucket(ulSize);
}
template <class V, class Hf, class Eq>
HashTable<V,Hf,Eq>::HashTable(unsigned long ulSize):m_ulCurSize(0),m_bucket(NULL),m_ulFullSize(0)
{
init_bucket(ulSize);
}
template <class V, class Hf, class Eq>
HashTable<V,Hf,Eq>::~HashTable()
{
if(m_bucket != NULL)
free(m_bucket);
}
template <class V>
__hash_node<V>* create_node(const V& obj)
{
__hash_node<V>* p = new __hash_node<V>;
p->next = NULL;
p->val = obj;
return p;
}
template <class V>
void destory_node(__hash_node<V>* p)
{
delete p;
}
template <class V, class Hf, class Eq>
void HashTable<V,Hf,Eq>::init_bucket(unsigned long ulSize)
{
m_ulFullSize = LowerBound(prime_list, number_of_primes, ulSize);
m_bucket = (node**)malloc(sizeof(node*) * m_ulFullSize);
memset(m_bucket, 0, sizeof(node*) * m_ulFullSize);
}
template <class V, class Hf, class Eq>
void HashTable<V,Hf,Eq>::resize(bool isUnique)
{
if(m_ulCurSize > m_ulFullSize && m_ulCurSize < prime_list[number_of_primes-1])
{
node** oldbucket = NULL;
node *p = NULL,*q = NULL;
unsigned long ulSize = 0;
printf("resize() cursize:%ld , fullsize:%ld,\n", m_ulCurSize, m_ulFullSize);
oldbucket = m_bucket;
ulSize = m_ulFullSize;
m_ulCurSize = 0;
m_ulFullSize = LowerBound(prime_list, number_of_primes, m_ulFullSize + 1);
m_bucket = (node**)malloc(sizeof(node*) * m_ulFullSize);
memset(m_bucket, 0, sizeof(node*) * m_ulFullSize);
//将原来的所有元素移到新的bucket中
for(unsigned long i=0; i< ulSize; i++)
{
if(oldbucket[i] == NULL)
continue;
q = oldbucket[i];
do
{
if(isUnique)
insert_unique_noresize(q->val);
else
insert_equal_noresize(q->val);
p = q;
q = q->next;
destory_node(p);
}while(q != NULL);
}
if(oldbucket != NULL)
free(oldbucket);
}
}
template <class V, class Hf, class Eq>
int HashTable<V,Hf,Eq>::insert_unique_noresize(const V& obj)
{
unsigned long key = m_hash(obj, m_ulFullSize);
node *p = NULL, *q = NULL;
bool isExist = false;
if(m_bucket[key] == NULL)
{
m_bucket[key] = create_node(obj);
}
else
{
q = m_bucket[key];
do
{
if(m_equals(q->val, obj))
{
//已经存在相同的节点了。
isExist = true;
break;
}
p = q;
q = q->next;
}while(q != NULL);
if(!isExist)
{
p->next = create_node(obj);
}
}
m_ulCurSize ++;
return 1;
}
template <class V, class Hf, class Eq>
int HashTable<V,Hf,Eq>::insert_unique(const V& obj)
{
insert_unique_noresize(obj);
resize(true);
return 1;
}
template <class V, class Hf, class Eq>
int HashTable<V,Hf,Eq>::insert_equal_noresize(const V& obj)
{
unsigned long key = m_hash(obj, m_ulFullSize);
node *p = NULL, *q = NULL;
p = create_node(obj);
if(m_bucket[key] == NULL)
{
m_bucket[key] = p;
}
else
{
p->next = m_bucket[key]->next;
m_bucket[key]->next = p;
}
m_ulCurSize ++;
return 1;
}
template <class V, class Hf, class Eq>
int HashTable<V,Hf,Eq>::insert_equal(const V& obj)
{
insert_equal_noresize(obj);
resize(false);
return 1;
}
template <class V, class Hf, class Eq>
int HashTable<V,Hf,Eq>::find(const V& obj)
{
unsigned long key = m_hash(obj, m_ulFullSize);
node *p = NULL;
if(m_bucket[key] != NULL)
{
p = m_bucket[key];
do
{
if(m_equals(p->val, obj))
return 1;
p = p->next;
}while(p != NULL);
}
else
return 0;
return 0;
}
#endif /* __HASHTABLE_H__ */
测试代码：
#include "stdafx.h"
#include "HashTable.h"
struct st
{
int key;
int value;
};
struct st_equal
{
bool operator() (const st& first, const st& second) const
{
return first.value == second.value;
}
};
struct st_hash
{
unsigned long operator() (const st& first, const unsigned long n) const
{
return first.value % n;
}
};
int _tmain(int argc, _TCHAR* argv[])
{
HashTable<st, st_hash, st_equal> myHashTable(10);
st tmp;
int count = 0;
for(unsigned long i = 0; i<4294967291; i++)
{
tmp.key = 10;
tmp.value = i;
myHashTable.insert_unique(tmp);
}
tmp.value = 10;
myHashTable.find(tmp);
tmp.value = 64;
myHashTable.find(tmp);
return 0;
}