C++ 简单 Hash容器的实现

主要实现了以整数为关键字的hash，以key%m_nSize为哈希函数，以(hash(key)+i)%m_nSize重新寻址，并附带了elf_hash的实现，使用过程中可灵活修改。

#ifndef _MY_HASH_INT_H_
#define _MY_HASH_INT_H_

template<class T,class K>
class HashInt{
public:
    HashInt();
    virtual ~HashInt();
private:
    typedef struct tagElement 
    {
        T data;
        K key;
        bool use;
        tagElement(){use = false;}
        ~tagElement(){}
    }Element;
    unsigned int m_nSize;
    Element *m_arrT;
    unsigned int m_nElementCnt;
    // 查找
    bool find(K key,unsigned int &index);
public:
    // 初始化，分配内存
    bool init(const unsigned int size);
    // 哈希函数
    unsigned int hash(K key);
    // ELF哈希函数
    unsigned int hash_elf(char *str);
    // 插入
    bool insert(T data,K key);
    // 删除
    bool remove(K key);
    // 查找
    bool find(K key,T &data);
    // 修改
    bool modify(T data,K key);
    void dump();
};

template<class T,class K>
unsigned int HashInt<T, K>::hash_elf( char *str)
{
    unsigned int locate = 0;
    unsigned int x = 0;
    while (*str)
    {
        locate = (locate << 4) + (*str++);//hash左移4位，当前字符ASCII存入hash低四位。 
        if ((x = locate & 0xF0000000L) != 0)
        {//如果最高的四位不为0，则说明字符多余7个，如果不处理，再加第九个字符时，第一个字符会被移出，因此要有如下处理。
            locate ^= (x >> 24);
            //清空28-31位。
            locate &= ~x;
        }
    }
    return locate%m_nSize;
}

template<class T,class K>
HashInt<T, K>::~HashInt()
{
    if(m_arrT != NULL)
    {
        delete[] m_arrT;
    }
}

template<class T,class K>
HashInt<T, K>::HashInt()
{
    m_arrT = NULL;
    m_nSize = 0;
    m_nElementCnt = 0;
}

template<class T,class K>
void HashInt<T, K>::dump()
{
    cout<<"m_nElementCnt="<<m_nElementCnt<<",m_nSize="<<m_nSize<<endl;
    for(unsigned int i = 0;i < m_nSize;i++)
    {
        if(m_arrT[i].use == true)
        {
            cout<<i<<"-";
            m_arrT[i].data->display();
        }
    }
    cout<<endl;
}

template<class T,class K>
bool HashInt<T, K>::modify( T data,K key )
{
    if( m_nElementCnt == 0)
    {
        return false;
    }
    bool exist = false;
    unsigned int index;
    exist = find(key,index);
    if( exist == true )
    {
        m_arrT[index].data = data;
    }
    return false;
}

template<class T,class K>
bool HashInt<T, K>::find( K key,T &data )
{
    if( m_nElementCnt == 0)
    {
        return false;
    }
    bool exist = false;
    unsigned int index;
    exist = find(key,index);
    if( exist == true )
    {
        data = m_arrT[index].data;
    }
    return false;
}


template<class T,class K>
bool HashInt<T, K>::find( K key,unsigned int &index )
{
    if( m_nElementCnt == 0)
    {
        return false;
    }
    unsigned int locate = hash(key),i = 1;
    while(i < m_nSize)
    {
        if( m_arrT[locate].use == true &&  m_arrT[locate].key == key)
        {
            index = locate;
            return true;
        }
        locate = (locate + i)%m_nSize;
        i++;
    }
    return false;
}


template<class T,class K>
bool HashInt<T, K>::remove( K key )
{
    // 表为空
    if( m_nElementCnt == 0 )
    {
        return false;
    }
    bool exist = false;
    unsigned int index;
    exist = find(key,index);
    if( exist == true )
    {
        m_arrT[index].use = false;
        m_nElementCnt--;
        return true;
    }
    return false;
}

template<class T,class K>
bool HashInt<T, K>::insert( T data,K key)
{
    // 表已满
    if( m_nElementCnt == m_nSize )
    {
        return false;
    }
    unsigned int locate = hash(key),i = 1;
    while(i < m_nSize)
    {
        if( m_arrT[locate].use == false)
        {
            m_arrT[locate].data = data;
            m_arrT[locate].key = key;
            m_arrT[locate].use = true;
            m_nElementCnt++;
            return true;
        }
        locate = (locate + i)%m_nSize;
        i++;
    }
    return false;
}

template<class T,class K>
unsigned int HashInt<T, K>::hash( K key )
{
    return key%m_nSize;
}

template<class T,class K>
bool HashInt<T, K>::init( const unsigned int size )
{
    m_nSize = size;
    m_arrT = new Element[m_nSize];
    m_nElementCnt = 0;
    cout<<"size = "<<sizeof(Element)*m_nSize<<endl;
    return true;
}

#endif