哈希桶的实现

#pragma once
#include<vector>

template<class K>
struct __HashFunc
{
    size_t operator()(const K&key)
    {
        return key;
    }
};

template<>
struct __HashFunc<string>   //特化
{
    static size_t BKDRHash(const char*str)    //BKDRHash算法
    {

        unsigned int seed = 131;// 31 131 1313 13131 131313
        unsigned int hash= 0;
        while (*str)
        {
            hash = hash*seed + (*str++);
        }
        return(hash & 0x7FFFFFFF);
    }

    size_t operator()(const string& str)
    {
        return BKDRHash(str.c_str());
    }
};

template<class K,class V>
struct KVNode
{
    K _key;
    V _value;
    KVNode<K, V>* _next;

    KVNode(const K& key, const V& value)
        :_key(key)
        , _value(value)
        , _next(NULL)
    {}
};
template<class K, class V, template<class> class HashFunc = __HashFunc>
class Hash
{
public:
      typedef KVNode<K, V> Node;
    Hash()     //构造函数
        :_size(0)
    {}

    ~Hash()     //析构函数
    {
        Clear();
    }

    Hash(const Hash& ht)    //拷贝构造函数
    {
        Copy(ht);
    }

    Hash& operator=(const Hash&ht)      //赋值运算符的重载
    {
        if (this != &ht)
        {
            Clear;
            Copy(ht);
        }
        return *this;
    }

    bool Insert(const K& key,const V& value)   //插入节点
    {
        _CheckSize();     //检查容量，看是否需要扩容
        size_t index = _HashFunc(key,_tables.size());
        if (Find(key))       //如果有这个值则说明不需要插入
            return false;
       
        //单链表的头插
        Node* head = _tables[index];
        Node* tmp = new Node(key, value);
        tmp->_next =head;
        _tables[index] = tmp;
        ++_size;
        return true;
    }

    //bool Insert(const K& key, const V&value)
    //{
    //    _CheckSize();
    //    size_t index = _HashFunc(key, _tables.size());
    //    Node*begin = _tables[index];
    //    while (begin)
    //    {
    //        if (begin->_key== key)
    //        {
    //            return false;
    //        }
    //        begin = begin->_next;
    //    }
    //    Node* head = _tables[index];
    //    Node* tmp = new Node(key, value);   //头插
    //    tmp->_next = head;
        /*_tables[index] = tmp;
        ++_size;
        return true;
    }*/

    /*bool Remove(const K& key)
    {
        size_t index = _HashFunc(key,_tables.size());
        Node* cur = _tables[index];
        Node* prev = NULL;
        while (cur)
        {
            if (cur->_key == key)
            {
                if (prev == NULL)
                    _tables[index] = cur->_next;
                else
                    prev->_next = cur->_next;
            
                delete cur;
                --_size;
                return true;
            }    
            prev = cur;
            cur = cur->_next;
        }
        return false;
    }*/

    bool Remove(const K& key)    //删除节点的函数
    {
        size_t index = _HashFunc(key, _tables.size());
        Node* cur = _tables[index];
        if (cur == NULL)
            return false;

        if (cur->_key == key)   //key为桶的头结点
        {
            _tables[index] = cur->_next;
            delete cur;
            --_size;
            return true;
        }

        Node* prev = cur;  //key为桶的中间节点
        cur = cur->_next;
        while (cur)
        {
            if (cur->_key == key)
            {
                prev->_next = cur->_next;
                delete cur;
                --_size;
                return true;
            }
            prev = prev;
            cur = cur->_next;
        }
        return false;
    }

    Node* Find(const K& key)    //查找节点
    {
        size_t index = _HashFunc(key,_tables.size());
        Node* cur = _tables[index];
        while (cur)
        {
            if (cur->_key == key)
                return cur;
            cur = cur->_next;
        }
        return NULL;
    }

    void Print()    //打印哈希桶
    {
        cout << "capacity" << "    " << "size" << ":" << _tables.size() << "   " << _size << endl;
        for (size_t i = 0; i < _tables.size(); ++i)
        {
            Node* cur = _tables[i];
            if (cur == NULL)
            {
                continue;
            }
            //cout << "[" << i << "]" << "    ";
            printf("【%d】", i);
            while (cur)
            {
                cout << "{" << cur->_key << "," << cur->_value << "}->";
                cur = cur->_next;
            }
            cout << "NULL" << endl;
        }
    }
//protected:
    void _CheckSize()     //检查容量，如果需要扩容就进行扩容
    {
        if (_size == 0 || _size == _tables.size())   
        {
            size_t capacity = _GetnextPrime(_size);
            vector<Node*> Hashtable;
            Hashtable.reserve(capacity);
            Hashtable.assign(capacity, 0);
            for (size_t i = 0; i < _tables.size(); ++i)
            {
                Node* begin = _tables[i];
                while (begin)
                {
                    Node* tmp = begin;
                    begin = begin->_next;

                    size_t index = _HashFunc(tmp->_key,capacity);

                    Node* head = Hashtable[index];
                    tmp->_next = head;
                    Hashtable[index] = tmp;
                }
            }
            _tables.swap(Hashtable);
        }
    }

    size_t _GetnextPrime(size_t num)
    {
        const int _Primesize = 28;
        static const unsigned long _PrimeList[_Primesize] =
        {
            53ul, 97ul, 193ul, 389ul, 769ul,
            1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
            49157ul, 98317ul, 196613ul, 393241ul,
            786433ul,
            1572869ul, 3145739ul, 6291469ul, 12582917ul,
            25165843ul,
            50331653ul, 100663319ul, 201326611ul, 402653189ul,
            805306457ul,
            1610612741ul, 3221225473ul, 4294967291ul
        };

        for (size_t i = 0; i < _Primesize; ++i)
        {
            if (_PrimeList[i]>num)
            {
                return _PrimeList[i];
            }
            return _PrimeList[_Primesize - 1];
        }
    }

    size_t _HashFunc(const K& key,size_t capacity)
    {
        return HashFunc<K>()(key) %capacity;
    }

    void Clear()   //素组中的元素是指针，因此要特别注意先释放每个节点下的单链表，否则造成内存泄漏
    {
        for (size_t i = 0; i < _tables.size(); ++i)
        {
            Node* cur = _tables[i];
            while (cur)
            {
                Node* del = cur;
                cur = cur->_next;
                delete del;
            }
            _tables[i] = NULL;
        }
    }

    void Copy(const Hash& ht)     //拷贝函数
    {
        _tables.resize(ht._tables.size());
        for (size_t i = 0; i < _tables.size(); ++i)
        {
            Node* cur = ht._tables[i];
            while (cur)
            {
                Node* newCur = new Node(cur->_key, cur->_value);
                newCur->_next = _tables[i];
                _tables[i] = newCur;
                cur = cur->_next;
            }
        }
    }
protected:
    vector<Node*> _tables;
    size_t _size;
};