hash_table

c++11之前，标准库里的哈希容器是std::hash_set、std::hash_multiset、std::hash_map、std::hash_multisetmap；

c++11之后，他们的名字改成了std::unorder_set、std::unorder_multiset、std::unoreder_map、std::unorder_multimap, 称之为无序容器，这个实现比之前的要复杂很多。

标准库的hash容器的底层数据结构自然是基于hash表，自己参考旧版本实现hashtable。

hashtable的数据结构原理大致如下图：

 

 

 

#ifndef __MY_HASH_TABLE_H_
#define __MY_HASH_TABLE_H_
#include <functional>
#include <vector>
#include <algorithm>
// hash节点
template <typename Value>
struct Hashtable_node
{
    Hashtable_node(Value val):value(val), next(nullptr) {}
    Hashtable_node*        next;
    Value                value;
};

// 先声明模板类和迭代器
template<typename Value, typename Key, typename Hash, typename ExtractKey, typename Equal>
class MyHashtable;
template <typename Value, typename Key, typename Hash, typename ExtractKey, typename Equal>
struct Hashtable_iterator;

// 定义迭代器
template <typename Value, typename Key, typename Hash, typename ExtractKey, typename Equal>
struct Hashtable_iterator 
{
    // 类型声明
    typedef MyHashtable<Value, Key, Hash, ExtractKey, Equal>        Hashtable;
    typedef Hashtable_iterator<Value, Key, Hash, ExtractKey, Equal>    iterator;
    typedef Hashtable_node<Value>                                    Node;

    typedef Value value_type;
    typedef Value& reference;
    typedef Value* pointer;

    Node*                    m_curNode;     // 指向的自身节点
    Hashtable*                m_hashtable;  // 指向的hash表对象

    // 构造函数
    Hashtable_iterator(Node* node,Hashtable* hashtable) : m_curNode(node), m_hashtable(hashtable) {}
    Hashtable_iterator() : m_curNode(nullptr), m_hashtable(nullptr) {}

    // 重载操作符,注意hashtable的迭代器无自减操作
    reference operator*() const { return m_curNode->value; }
    pointer operator->() const { return &(operator*()); }
    iterator& operator++() // 前++
    {
        const Node* old = m_curNode;
        m_curNode = m_curNode->next; // 先链表自增
        if (!m_curNode) 
        {   // 如果桶只有一个节点，就取下一个桶, 循环直到取得非空的节点
            size_t bucket = m_hashtable->get_bkt_num(old->value, m_hashtable->m_buckets.size());
            while (!m_curNode && ++bucket < m_hashtable->m_buckets.size())
            {
                m_curNode = m_hashtable->m_buckets[bucket];
            }
        }
        return *this;
    }
    iterator operator++(int) // 后++
    {
        iterator __tmp = *this;
        ++*this;
        return __tmp;
    }
    bool operator==(const iterator& it) const
    {
        return m_curNode == it.m_curNode;
    }
    bool operator!=(const iterator& it) const
    {
        return m_curNode != it.m_curNode;
    }
};

// Note: assumes long is at least 32 bits.
enum { num_primes = 28 };

// 质数表，bucket的个数从该表中取，因为bucket下标值是哈希值取余bucket的size,如果size为质数，会减少冲突
static const unsigned long prime_list[num_primes] =
{
  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
};

// 在质数表中查找第一个大于或等于n的质数
inline unsigned long next_prime(unsigned long n)
{
    const unsigned long* first = prime_list;
    const unsigned long* last = prime_list + (int)num_primes;
    const unsigned long* pos = std::lower_bound(first, last, n);
    return pos == last ? *(last - 1) : *pos;
}

// 定义模板类
template <typename Value, typename Key, typename Hash, typename ExtractKey, typename Equal>
class MyHashtable
{
private:
    typedef Hashtable_node<Value> Node;
public:
    typedef Hashtable_iterator<Value, Key, Hash, ExtractKey, Equal> iterator;
    typedef Value    value_type;
    typedef Value&    reference;
    typedef Value*    pointer;
    typedef Key        key_type;
public:
    MyHashtable(size_t n) 
      : m_hash(Hash()),
        m_equals(Equal()),
        m_get_key(ExtractKey()),
        m_num_elements(0)
    {
        initialize_buckets(n);
    }
    MyHashtable(const MyHashtable& hashtable)
        : m_num_elements(0)
    {
        copy_from(hashtable);
    }

    MyHashtable& operator= (const MyHashtable& hashtable)
    {
        if (&hashtable != this)
        {
            clear();
            copy_from(hashtable);
        }
        return *this;
    }

    // 析构函数
    ~MyHashtable() { clear(); }

    // 获取size
    size_t size() const { return m_num_elements; }
    // 判断是否为空
    bool empty() const { return size() == 0; }
    // 交换函数
    void swap(MyHashtable& hashtable)
    {
        m_buckets.swap(hashtable.m_buckets);
        std::swap(m_num_elements, hashtable.m_num_elements);
    }
    // 指向第一个元素的迭代器
    iterator begin()
    {
        for (size_t n = 0; n < m_buckets.size(); ++n)
        { // 找到第一个非空的bucket
            if (m_buckets[n])
            {
                return iterator(m_buckets[n], this);
            }
        }
        return end();
    }
    iterator end() { return iterator(0, this); } // 直接指向空指针的迭代器
    // 获取bucket的个数
    size_t bucket_count() const { return m_buckets.size(); }

    // 用于非multi容器的插入
    std::pair<iterator, bool> insert_unique(const value_type& obj)
    {
        resize(m_num_elements + 1);
        return insert_unique_noresize(obj);
    }
    // 用于multi容器的插入
    iterator insert_equal(const value_type& obj)
    {
        resize(m_num_elements + 1);
        return insert_equal_noresize(obj);
    }
    // 获取bucket下标
    size_t get_bkt_num(const value_type& obj, size_t n) const
    {
        const key_type& key = m_get_key(obj);
        return m_hash(key) % n;
    }
    // 查找key值对应的迭代器
    iterator find(const key_type& key)
    {
        size_t n = m_hash(key) % m_buckets.size();
        Node* first;
        for (first = m_buckets[n]; first && !m_equals(m_get_key(first->value), key); first = first->next)
        { }
        iterator it = iterator(first,this);
        return it;
    }
    // 返回容器中key值节点的个数
    size_t count(const key_type& key) const
    {
        const size_t n = m_hash(key) % m_buckets.size();
        size_t result = 0;
        for (const Node* cur = m_buckets[n]; cur; cur = cur->next)
        {
            if (m_equals(m_get_key(cur->value), key))
            {
                ++result;
            }
        }
        return result;
    }
    // 查找obj，如果找到就返回，如果找不到就插入obj
    reference find_or_insert(const value_type& obj)
    {
        resize(m_num_elements + 1);
        size_t n = get_bkt_num(obj,m_buckets.size());
        Node* first = m_buckets[n];

        for (Node* cur = first; cur; cur = cur->next)
        {
            if (m_equals(m_get_key(cur->value), m_get_key(obj)))
            {
                return cur->value;
            }
        }

        Node* tmp = new Node(obj);
        tmp->next = first;
        m_buckets[n] = tmp;
        ++m_num_elements;
        return tmp->value;
    }

    // 删除所有key值节点，返回key值节点的个数
    size_t erase(const key_type& key)
    {
        const size_t n = m_hash(key) % m_buckets.size();
        Node* first = m_buckets[n];
        size_t erased = 0;

        if (first) 
        {
            Node* cur = first;
            Node* next = cur->next;
            while (next) 
            {
                if (m_equals(m_get_key(next->value), key)) 
                {
                    cur->next = next->next;
                    delete next;
                    next = cur->next;
                    ++erased;
                    --m_num_elements;
                }
                else 
                {
                    cur = next;
                    next = cur->next;
                }
            }
            if (m_equals(m_get_key(first->value), key)) 
            {
                m_buckets[n] = first->next;
                delete first;
                ++erased;
                --m_num_elements;
            }
        }
        return erased;
    }
    // 删除迭代器
    void erase(const iterator& it)
    {
        Node* p = it.m_curNode;
        if (p) 
        {
            const size_t n = get_bkt_num(p->value,m_buckets.size());
            Node* cur = m_buckets[n];
            if (cur == p) 
            {
                m_buckets[n] = cur->next;
                delete cur;
                --m_num_elements;
            }
            else 
            {
                Node* next = cur->next;
                while (next)
                {
                    if (next == p) 
                    {
                        cur->next = next->next;
                        delete next;
                        --m_num_elements;
                        break;
                    }
                    else {
                        cur = next;
                        next = cur->next;
                    }
                }
            }
        }
    }
private:
    // 初始化buckets
    void initialize_buckets(size_t n)
    {
        // 这里桶的数量取质数，减少取余桶数量的冲突
        const size_t nBuckets = next_prime(n); 
        m_buckets.reserve(nBuckets);
        // 全部初始化为空指针
        m_buckets.insert(m_buckets.end(), nBuckets, (Node*)0);
        m_num_elements = 0;
    }
    // 将hashtable的bucket拷贝到本地
    void copy_from(const MyHashtable& hashtable)
    {
        m_buckets.clear();
        m_buckets.reserve(hashtable.m_buckets.size());
        m_buckets.insert(m_buckets.end(), hashtable.m_buckets.size(), (Node*)0);
        for (size_t i = 0; i < hashtable.m_buckets.size(); ++i)
        {
            const Node* curNode = hashtable.m_buckets[i];
            if (curNode)
            {
                Node* copy = new Node(curNode->value);
                m_buckets[i] = copy;
                for (Node* next = curNode->next; next;curNode = next, next = curNode->next) 
                {
                    copy->next = new Node(next->value);
                    copy = copy->next;
                }
            }
        }
        m_num_elements = hashtable.m_num_elements;
    }
    // 释放所有节点
    void clear()
    {
        for (size_t i = 0; i < m_buckets.size(); ++i)
        {
            Node* curNode = m_buckets[i];
            while (curNode != 0) 
            {
                Node* next = curNode->next;
                delete curNode;
                curNode = next;
            }
            m_buckets[i] = 0;
        }
        m_num_elements = 0;
    }
    // 判读bucket的size是否够用，不够重新申请个vector
    void  resize(size_t num_elements_hint)
    {
        const size_t old_n = m_buckets.size();
        if (num_elements_hint > old_n)
        {
            const size_t n = next_prime(num_elements_hint);
            if (n > old_n)
            {
                std::vector<Node*> tmp(n, (Node*)(0));
                 for (size_t bucket = 0; bucket < old_n; ++bucket)
                 {
                    Node* first = m_buckets[bucket];
                    while (first)
                    {
                      size_t new_bucket = get_bkt_num(first->value, n);
                      m_buckets[bucket] = first->next;
                      first->next = tmp[new_bucket];
                      tmp[new_bucket] = first;
                      first = m_buckets[bucket];
                    }
                  }
                  m_buckets.swap(tmp);
            }
        }
    }
    // 非multi插入
    std::pair<iterator, bool> insert_unique_noresize(const value_type& obj)
    {
        const size_t n = get_bkt_num(obj, m_buckets.size());
        Node* first = m_buckets[n];
        for (Node* curNode = first; curNode; curNode = curNode->next)
        {
            if (m_equals(m_get_key(curNode->value), m_get_key(obj)))
            {
                return std::pair<iterator, bool>(iterator(curNode, this), false);
            }
        }
        Node* tmp = new Node(obj);
        tmp->next = first;
        m_buckets[n] = tmp;
        ++m_num_elements;
        return std::pair<iterator, bool>(iterator(tmp, this), true);
    }
    // multi参入
    iterator insert_equal_noresize(const value_type& obj)
    {
        const size_t n = get_bkt_num(obj, m_buckets.size());
        Node* first = m_buckets[n];

        for (Node* curNode = first; curNode; curNode = curNode->next)
        {
            if (m_equals(m_get_key(curNode->value), m_get_key(obj)))
            {
                Node*  tmp = new Node(obj);
                tmp->next = curNode->next;
                curNode->next = tmp;
                ++m_num_elements;
                return iterator(tmp, this);
            }
        }
        Node* tmp = new Node(obj);
        tmp->next = first;
        m_buckets[n] = tmp;
        ++m_num_elements;
        return iterator(tmp, this);
    }
private:
    Hash                                m_hash;
    Equal                                m_equals;
    ExtractKey                            m_get_key;
    std::vector<Hashtable_node<Value>*> m_buckets;
    size_t                                m_num_elements;
};
#endif//__MY_HASH_TABLE_H_