这个并不难写,因为存储结构很像图的邻接表,
写得算法成员函数也不多,大家可以补充的:
#ifndef OPEN_HASHTABLE_H
#define OPEN_HASHTABLE_H

#include<iostream.h>
#include<stdlib.h>
#define DefaultSize 100

/////////////////////////////////////////////////////////////
//HashNode结构的定义 即开散列表的结点的定义
/////////////////////////////////////////////////////////////
template<class T>
struct HashNode
{
    T key;            //结点的关键码域
    HashNode<T>* link;//结点的指针域
    HashNode(T x)     //构造函数
    {key=x;link=NULL;};
};
/////////////////////////////////////////HashNode结构定义结束

/////////////////////////////////////////////////////////////
//OpenHashTable类模板的实现
//即以开散列的方式实现的哈希表
/////////////////////////////////////////////////////////////
template<class T>
class OpenHashTable
{
private:
    int divisor;                    //除数(必须是质数)
    int TableSize;                  //表的大小
    HashNode<T>** ht;               //开散列表,即同义词链表的首指针的定义
   
public:
    OpenHashTable(int div,int sz);  //构造函数
    ~OpenHashTable();               //析构函数
    HashNode<T>* FindPos(T x)const; //找指定关键码的结点的指针

   
    bool Insert(const T x);         //把关键码为x的结点插入到开散列表中
    bool Remove(const T x);         //删除指定关键码的结点

    //友元重载<<运算符输出开散列表的内容
    friend ostream& operator<<(ostream& os,OpenHashTable<T>& OPHT);
};
//////////////////////////////////OpenHashTable类模板声明结束

/////////////////////////////////////////////////////////////
//析构函数
/////////////////////////////////////////////////////////////
template<class T>
OpenHashTable<T>::~OpenHashTable()
{
    //子桶链表不空
    if(ht!=NULL)
    {
        //依次释放每个子桶链表的内存空间
        for(int i=0;i<TableSize;i++)
        {
            if(ht[i]!=NULL)
            {
                //游标指针
                HashNode<T>* ptr=ht[i];
                //前个结点的指针
                HashNode<T>* pre=ht[i];
                while(ptr!=NULL)
                {
                    pre=ptr;      //保留前个结点指针
                    ptr=ptr->link;//向后推进
                    delete pre;   //删除结点
                };
            };
        };
    };
};
/////////////////////////////////////////////////析构函数结束

/////////////////////////////////////////////////////////////
//FindPos()公有成员函数
//找指定关键码的结点的指针
/////////////////////////////////////////////////////////////
template<class T>
HashNode<T>* OpenHashTable<T>::FindPos(T x)const
{
    //遍历散列表的内容
    for(int i=0;i<TableSize;i++)
    {
        //如果表头指针不空
        if(ht[i]!=NULL)
        {
            //游标指针
            HashNode<T>* ptr=ht[i];
            //遍历子桶的结点
            do
            {
                //如果找到,则返回
                if(ptr->key==x)
                    return ptr;
                //否则指针向后推进
                else
                    ptr=ptr->link;
            }while(ptr!=NULL);
        };
    };
    return NULL;
};
////////////////////////////////////////////FindPos()函数结束

/////////////////////////////////////////////////////////////
//Insert()公有成员函数
//把关键码为x的结点插入到开散列表中
/////////////////////////////////////////////////////////////
template<class T>
bool OpenHashTable<T>::Insert(const T x)
{
    HashNode<T>* newNode=new HashNode<T>(x);//为关键码x创建一个结点    
    int p=x%divisor;                        //计算该结点的桶号

    if(ht[p]==NULL)                         //如果该关键码对应的桶还是空的
        ht[p]=newNode;                      //作为桶链表的首指针
    else                                    //否则就从该桶链表开始搜索
    {
        HashNode<T>* ptr=ht[p];             //游标指针
    
        while(ptr->link!=NULL)              //直道最后一个结点
            ptr=ptr->link;                  //指针向后推进
        ptr->link=newNode;                  //把新结点挂上
    };

    return true;
};
/////////////////////////////////////////////Insert()函数结束

/////////////////////////////////////////////////////////////
//Remove()公有成员函数
//删除开散列表中指定关键码的结点
/////////////////////////////////////////////////////////////
template<class T>
bool OpenHashTable<T>::Remove(const T x)
{
    //如果要找的元素不存在
    if(FindPos(x)==NULL)
        return false;
    //如果存在的话开始搜索结点地址
    for(int i=0;i<TableSize;i++)
    {
        //如果表头指针不空
        if(ht[i]!=NULL)
        {
            //如果子桶第一个结点就是
            if(ht[i]->key==x)
            {
                //删除第一个结点
                ht[i]=ht[i]->link;
                return true;
            }
            else
            {
                //如果第一个结点不是要找的结点
                //游标指针
                HashNode<T>* ptr=ht[i];
                //搜索指定结点的前个结点的指针                
                while(ptr->link!=NULL)
                {
                    if(ptr->link->key==x)
                    {
                        //ptr结点后的那个结点删除
                        ptr->link=ptr->link->link;
                        return true;
                    }
                    else
                        //指针向后推进
                        ptr=ptr->link;
                };
            };
        };
    };
    return NULL;
};
/////////////////////////////////////////////Remove()函数结束

/////////////////////////////////////////////////////////////
//友元重载<<运算符输出开散列表的内容
/////////////////////////////////////////////////////////////
template<class T>
ostream& operator<<(ostream& os,OpenHashTable<T>& OPHT)
{
    //输出每个子桶链表的内容
    for(int i=0;i<OPHT.TableSize;i++)
    {
        os<<i<<":";
        //游标指针
        HashNode<T>* ptr=OPHT.ht[i];
        while(ptr!=NULL)
        {
            //显示结点内容
            os<<ptr->key<<" ";
            //推向下个结点指针
            ptr=ptr->link;
        };
        os<<endl;
    };    
    return os;
};
/////////////////////////////////////////////////友元重载结束

#endif

这些代码我自己留着也没有用啊...