哈希表

#include<iostream>  
#include<vector>  
#include<string>  
using namespace std;
template<class K, class V>
struct Node
{
    K _key;
    V _value;
    Node*_next;
    Node(const K& key, const V& value)
        :_key(key)
        ,_value(value)
        ,_next(NULL)
    {}
};
template<class T>
struct Hasher
{
    size_t operator() (const T& key)
    {
        return key;
    }
};

template<>
struct Hasher<string>
{
    size_t operator() (const string& s)
    {
        const char* str = s.c_str();

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

        return (hash & 0x7FFFFFFF);
    }
};

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
};
template<class K, class V, class HashFunc = Hasher<K>>
class HashTable
{
public:
    HashTable(size_t capacity)
    {
        _size = 0;
        _table.reserve(capacity);
        _table.assign(capacity, NULL);
    }
    void Insert(const K& key, const V& value)//放入数据  
    {
        ExpandCapacity();

        int pos = _HashFunc(key, _table.size());
        Node<K, V>*begin = _table[pos];
        while (begin != NULL)
        {
            if (begin->_key == key)
            {
                return;
            }
            begin = begin->_next;
        }
        Node<K, V>*tmp = new Node<K, V>(key, value);
        tmp->_next = _table[pos];
        _table[pos] = tmp;
        ++_size;
    }
    void Delete(const int&key)//删除结点  
    {
        size_t pos = (size_t)key % (size_t)_table.capacity();
        Node*begin = _table[pos];
        Node*prev = NULL;
        while (begin)
        {
            if (begin->_key == key)
            {
                if (begin == _table[pos])
                {
                    _table[pos] = _table[pos]->_next;
                }
                else
                {
                    prev->_next = begin->_next;
                }
                delete begin;
                return;
            }
            prev = begin;
            begin = begin->_next;
        }
    }
    void Print()
    {
        for (int i = 24; i <(int)_table.capacity(); i++)
        {
            Node<K, V>*begin = _table[i];
            while (begin != NULL)
            {
                printf("pos[%d]:", i);
                cout << "(" << begin->_key << "," << begin->_value << ")";
                cout << "->";
                begin = begin->_next;
            }
            cout << "NULL" << endl;
        }
    }

protected:
    void ExpandCapacity()//实现扩容  
    {
        if (_size >= (size_t)_table.capacity())
        {
            int NewCapacity = CapacityNum(_size);
            vector<Node<K, V> *>tmp;
            tmp.reserve(NewCapacity);
            tmp.assign(NewCapacity, NULL);
            for (size_t i = 0; i < (size_t)_table.capacity(); i++)
            {
                while (_table[i] != NULL)
                {
                    //摘节点  
                    Node<K, V>* head = _table[i];
                    _table[i] = _table[i]->_next;

                    //放节点  
                    int pos = _HashFunc((head->_key), NewCapacity);
                    head->_next = tmp[pos];
                    tmp[pos] = head;
                }
            }
            _table.swap(tmp);
        }
    }
    size_t CapacityNum(size_t num) //得到应该扩展到的容量值  
    {
        for (int i = 0; i < _PrimeSize; i++)
        {
            if (_PrimeList[i]>num)
            {
                return _PrimeList[i];
            }
        }
        return _PrimeList[_PrimeSize - 1];
    }

    int _HashFunc(const K& key, size_t capacity)
    {
        HashFunc hashFunc; // operator()  
        return hashFunc(key) % _table.capacity();

    }
private:
    vector<Node<K, V>*>_table;
    size_t _size;
};
int main()
{
    system("pause");
    return 0;
}