C++ HashMap

C++ HashMap

参考自boost库。

基本原理：

使用连续的内存块（数组）来存储数据，通过一个hash函数（即使每一个元素值都能形成固定的数组下标值），然后数组在相应的位置存起来，不能保证每个元素的关键值与hash函数值是一一对应的（可以有多个元素生成一样的hash值），这时候就需要解决冲突。
我们把数组叫做桶（因为数组把很多相似的元素存放在同一个位置）。

流程：

查找元素
- 元素的关键值通过hash函数计算得到hash值
- 得到桶号（数组下标位置）
- 比较桶的元素值（因为只有一次hash函数的值并不准确）
- 取出相同的元素的关键值，不相等则结束

插入元素
- 元素的关键值通过hash函数计算得到hash值
- 得到桶号（数组下标位置）
- 存放元素

我们需要一个提供hash函数的工具。写出一个行为类，重载()运算符。

class CalculateHashCode
{
public:
  std::size_t operator()(const string& str)
  {
    std::size_t n = 0;
    std::size_t nIndex = str.length();
    while (nIndex) {
      n <<= 5;
      if ((--nIndex)& 1) {
        n += str[nIndex] * 3;
      }
      else {
        n ^= ((n >> 17) | 0x01) * str[nIndex];
      }
    }
    return n;
  }
  std::size_t operator()(const wstring& str)
  {
    std::size_t n = 0;
    std::size_t nIndex = str.length();
    while (nIndex) {
      n <<= 5;
      if ((--nIndex) & 1) {
        n += str[nIndex];
      }
      else {
        n ^= ((n >> 17) | 0x01) * str[nIndex];
      }
    }
    return n;
  }
  std::size_t operator()(const short& nNum)
  {
    return nNum;
  }
  std::size_t operator()(const unsigned short& nNum)
  {
    return nNum;
  }
  std::size_t operator()(const char& nNum)
  {
    return nNum;
  }
  std::size_t operator()(const unsigned char& nNum)
  {
    return nNum;
  }
  std::size_t operator()(const size_t& nNum)
  {
    return nNum;
  }
  std::size_t operator()(const int& nNum)
  {
    return nNum;
  }
  std::size_t operator()(const long long& nNum)
  {
    return (std::size_t)(nNum >> 31 ^ nNum);
  }
  std::size_t operator()(const unsigned long long& nNum)
  {
    return (std::size_t)(nNum >> 31 ^ nNum);
  }
  std::size_t operator()(const float& nNum)
  {
    return (std::size_t)(nNum * 50331653.333333f);
  }
  std::size_t operator()(const double& nNum)
  {
    return (std::size_t)(nNum * 50331653.333333);
  }
  std::size_t operator()(const long double& nNum)
  {
    return (std::size_t)(nNum * 50331653.333333);
  }
};

HashMap：

hashMap应该是一个泛型容器，这里使用类模板来抽象数据类型。当然啦，也可以用void*来做出泛型。

template<typename Key, 
  typename Value, 
  typename CalcHash = CalculateHashCode>

三个类型参数名分别是元素的关键字，元素的内容值和计算hash的工具类型，这里我们默认为提供工具类型的是我们所写的计算hash类。

数据成员：

  typedef struct _tagBucket
  {
    iterator _first; //list某一个桶的开始
    iterator _last;  //list某一个桶的最后一个元素
  }Bucket;
  list<ValueType> _listValues;
  Bucket* _arrBuckets;
  std::size_t _nBucketSize;
  CalcHash _calcHash;

_listValues。使用标准库的双向链表来存放全部数据，为什么这样做呢？前面我们说过了当元素关键字冲突，计算到了一个被使用桶时候，这时候需要解决冲突问题，这里我们用将元素插入链表来解决，该方法称为链地址法。
_arrBuckets。 一个我们自定义的数据类型“Bucket”，我们只存放链表的区间范围的迭代器，这样就不需要为每一个桶都做一个链表，而是将每一个桶都想象为一个链表的某一个区间。
_nBucketSize。 桶的大小。
_calcHash。 计算hash值。

供外部使用的类型：

  typedef typename pair<Key, Value> ValueType;
  typedef typename list<ValueType>::iterator iterator;
  typedef typename  list<ValueType>::const_iterator const_iterator;

ValueType。标准库里，一对出现的元素都是用pair来解决的，我们也一样。
iterator。遍历链表元素。
const_iterator。遍历链表const元素。
内部方法：
我们将使用hash函数值的函数都是为私有的方法。

  iterator find(const Key& k, std::size_t nHashCode);
  Value& at(const Key& k, std::size_t nHashCode);
  pair<iterator, bool> insert(const ValueType& v, std::size_t nHashCode);
  void erase(iterator it, std::size_t nHashCode);
  void reHashSize(std::size_t nHashBucketSize);
  static std::size_t hashSize(std::size_t nNumber);//静态函数

find方法：通过一个元素关键字来查找，需要一个hash值，成功返回元素迭代器，失败放回end迭代器。
at方法：通过一个元素关键字来查找，需要一个hash值，成功返回元素的内容，失败插入一个相同关键字并初始化内容的元素，然后返回元素的内容。
insert：插入一个元素，需要一个hash值。不允许重复关键字，成功返回该元素迭代器，bool值为true，失败返回end迭代器，bool值为false。
erase：该元素的迭代器，需要一个hash值（需要知道桶的位置）。
reHashSize：该容器可以扩容。需要一个桶的大小值。
hashSize：通过一个值，提供一个等于该值或者大于该值的值。（提供合适的值，提供素数是不错的办法）

供外部使用的方法：

  HashMap()
    :_calcHash(CalcHash()), _listValues(), _nBucketSize(0), _arrBuckets(nullptr)
  {
    reHashSize(hashSize(1));
  }

  HashMap(const CalcHash& func)
    :_calcHash(func), _listValues(), _nBucketSize(0), _arrBuckets(nullptr) 
  {
    reHashSize(hashSize(1));
  }

  HashMap(const HashMap<Key, Value, CalcHash>& hashMap)
    :_calcHash(hashMap._calcHash), _listValues(hashMap._listValues), _nBucketSize(0), _arrBuckets(nullptr)
  {
    reHashSize(hashSize(_listValues.size()));
  }

  HashMap(const initializer_list<ValueType>& list, const CalcHash& func = CalcHash())
    :_calcHash(func), _listValues(list), _nBucketSize(0), _arrBuckets(nullptr)
  {
    reHashSize(hashSize(_listValues.size()));
  }

  ~HashMap()
  {
    if (_arrBuckets)
      delete[] _arrBuckets;
  }

  std::size_t BucketSize()
  {
    return _nBucketSize;
  }
    iterator begin()
  {
    return _listValues.begin();
  }

  iterator end()
  {
    return _listValues.end();
  }

  const_iterator cbegin() const
  {
    return _listValues.begin();
  }

  const_iterator cend() const
  {
    return _listValues.end();
  }

  bool empty()
  {
    return _listValues.empty();
  }

  Value& at(const Key& k)
  {
    if ((_listValues.size()) >= (_nBucketSize << 1))
      reHashSize(hashSize(_listValues.size()));
    return at(k, calcHashCode(k));
  }

  HashMap<Key, Value, CalcHash>& operator<<(const ValueType& v)
  {
    at(v.first) = v.second;
    return *this;
  }

  Value& operator[](const Key& k)
  {
    return at(k);
  }

  iterator find(const Key& k)
  {
    return find(k, calcHashCode(k));
  }

  void erase(iterator it)
  {
    erase(it, calcHashCode(it->first));
  }

  void erase(const Key& k)
  {
    std::size_t nHashCode = calcHashCode(k);
    erase(find(k, nHashCode), nHashCode);

  }

  pair<iterator, bool> insert(const ValueType& v)
  {
    if ((_listValues.size()) >= (_nBucketSize << 1))
      reHashSize(hashSize(_listValues.size()));
    return insert(v, calcHashCode(v.first));
  }

  void clear()
  {
    _listValues.clear();
    iterator end = _listValues.end();
    for (size_t i = 0; i != num_buckets_; ++i)
      buckets_[i].first = buckets_[i].last = end;
  }

大家，都自己实现自己的HashMap吧！