hash

采用引用计数来解决指针管理问题。开放地址、双重哈希来解决碰撞和探测问题， 实现了哈希表的创建、查找、插入，复制控制，[]操作符… 但总觉得欠缺点什么。

源码：

//hash.h
//2011/11/13   By Adoo
#ifndef  HASH_H
#define HASH_H
template<typename type,typename long (*count_key)(type)>
class hash{
public:
hash(std::size_t size, const type empty, const type deleted):_size(size),
_ref_count(new std::size_t (1)),table(NULL),_empty(empty),_deleted(deleted)
{
//get the adjacency prime with the size;
do{
if(is_prime(_size))
break;
else
++_size;
}while(true);
//allocate the memoey
table=new type[_size]();
for(std::size_t i=0 ; i!=_size; ++i)
{
table[i]=_empty;
}
}
~hash()
{
decr_cout();
}
bool insert(const type& k)
{//insert an element k to hash table
long a=std::abs(count_key(k));
for(size_t i=0; i!=_size; ++i)
{
long index=hash_function(count_key(k),i);
if(table[index]==_empty || table[index]==_deleted)
{
table[index]=k;
return true;
}
}
return false;
}
const type& search(const type& k)
{
long key=std::abs(count_key(k));
for(std::size_t i=0; i!=_size; ++i)
{
type ty=table[hash_function(key,i)] ;
if( ty== k )
return  table[hash_function(key,i)] ;
if(ty=_empty)
break;
}
return _empty;
}
hash(const type& t)
{
++*t.ref_count;
decr_count();
ref_count=t.ref_count;
table=t.table;
}
hash& operator=(const hash& t){
++*t.ref_count;
decr_count();
ref_count=t.ref_count;
table=t.table;
return *this;
}
const type& operator[](const type& t){
return search(t);
}
const hash& operator=(const hash& t) const{
++*t.ref_count;
decr_count();
ref_count=t.ref_count;
table=t.table;
_empty=t._empty;
_deleted=t._deleted;
return *this;
};
private:
void decr_cout()
{
if(!--*_ref_count)
{
delete _ref_count;
delete [] table;
}
}
long hash_function(long key,std::size_t count)
{
return (key%_size + count* (1 + key%(_size - 1)) % _size);
}
bool  is_prime(std::size_t l)
{
bool prime=true;
std::size_t sqrt=std::sqrtl( l )+1;
for(int i=2; i!=sqrt; ++i)
{
if(l%i ==0 )
{
prime=false;
break;
}
}
return prime;
}
private:
std::size_t  _size;
std::size_t  *_ref_count;
type   *table;
const type _empty;
const type _deleted;
};
#endif