mirror of
https://github.com/yanyiwu/cppjieba.git
synced 2025-07-18 00:00:12 +08:00
230 lines
5.3 KiB
C++
230 lines
5.3 KiB
C++
#ifndef LIMONP_HASH_MAP_HPP
|
|
#define LIMONP_HASH_MAP_HPP
|
|
|
|
#include <utility>
|
|
#include <cstdlib>
|
|
#include <cassert>
|
|
#include <algorithm>
|
|
#include <vector>
|
|
#include <iostream>
|
|
|
|
namespace limonp {
|
|
|
|
static size_t PRIME_NUMBERS[] = {3, 7, 17, 37, 79, 163, 331,
|
|
673, 1361, 2729, 471, 10949,
|
|
21911, 43853, 87719, 175447, 350899,
|
|
701819, 1403641, 2807303, 5614657, 11229331,
|
|
22458671, 44917381, 89834777, 179669557, 359339171,
|
|
718678369, 1437356741, 2147483647
|
|
};
|
|
|
|
template <class KeyT, class MappedT>
|
|
class HashMap {
|
|
private:
|
|
typedef std::pair<KeyT, MappedT> ValueT;
|
|
|
|
class LightList {
|
|
public:
|
|
struct Node {
|
|
ValueT value;
|
|
struct Node* next;
|
|
}; // struct Node
|
|
|
|
LightList()
|
|
: head_(NULL) {
|
|
}
|
|
LightList(const LightList& ll)
|
|
: head_(NULL) {
|
|
struct Node* node = ll.head_;
|
|
while (node != NULL) {
|
|
UniqAppend(node->value);
|
|
node = node->next;
|
|
}
|
|
}
|
|
~LightList() {
|
|
while (head_ != NULL) {
|
|
Node* x = head_;
|
|
head_ = head_->next;
|
|
delete x;
|
|
}
|
|
}
|
|
|
|
//O(n)
|
|
std::pair<ValueT&, bool> UniqAppend(const ValueT& x) {
|
|
struct Node** pp = &head_;
|
|
while ((*pp) != NULL) {
|
|
if ((*pp)->value.first == x.first) {
|
|
(*pp)->value.second = x.second;
|
|
return std::pair<ValueT&, bool>((*pp)->value, false);
|
|
}
|
|
pp = &(*pp)->next;
|
|
}
|
|
struct Node* node = new Node;
|
|
node->value = x;
|
|
node->next = NULL;
|
|
(*pp) = node;
|
|
return std::pair<ValueT&, bool>(node->value, true);
|
|
}
|
|
|
|
//O(1)
|
|
void PushFront(const ValueT& x) {
|
|
Node* node = new Node;
|
|
node->value = x;
|
|
node->next = head_;
|
|
head_ = node;
|
|
}
|
|
private:
|
|
LightList& operator = (const LightList& ll);
|
|
|
|
friend class HashMap;
|
|
friend class Iterator;
|
|
|
|
Node* head_;
|
|
}; // class LightList
|
|
|
|
template<class BucketsT, class NodeT, class ValueT>
|
|
class Iterator {
|
|
public:
|
|
Iterator() {
|
|
}
|
|
|
|
Iterator& operator ++() {
|
|
assert(buckets_ != NULL);
|
|
assert(node_ != NULL);
|
|
node_ = node_->next;
|
|
while (node_ == NULL) {
|
|
++bucketid_;
|
|
if (bucketid_ >= buckets_->size()) {
|
|
break;
|
|
}
|
|
node_ = (*buckets_)[bucketid_].head_;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
bool operator == (const Iterator& iter) const {
|
|
return node_ == iter.node_;
|
|
}
|
|
|
|
bool operator != (const Iterator& iter) const {
|
|
return node_ != iter.node_;
|
|
}
|
|
|
|
ValueT* operator -> () {
|
|
assert(node_ != NULL);
|
|
assert(bucketid_ < buckets_->size());
|
|
return &node_->value;
|
|
}
|
|
ValueT& operator * () {
|
|
assert(node_ != NULL);
|
|
assert(bucketid_ < buckets_->size());
|
|
return node_->value;
|
|
}
|
|
private:
|
|
friend class HashMap;
|
|
Iterator(size_t bucketid, BucketsT buckets, NodeT node)
|
|
: bucketid_(bucketid), buckets_(buckets), node_(node) {
|
|
}
|
|
size_t bucketid_;
|
|
BucketsT buckets_;
|
|
NodeT node_;
|
|
}; // class Iterator
|
|
|
|
public:
|
|
typedef Iterator<const std::vector<LightList>*, const struct LightList::Node*, const ValueT> const_iterator;
|
|
|
|
HashMap()
|
|
: size_(0) {
|
|
}
|
|
~HashMap() {
|
|
}
|
|
|
|
size_t Size() const {
|
|
return size_;
|
|
}
|
|
|
|
size_t BucketSize() const {
|
|
return buckets_.size();
|
|
}
|
|
|
|
bool Insert(const ValueT& v) {
|
|
size_ ++;
|
|
if (size_ > buckets_.size()) {
|
|
const size_t* begin = PRIME_NUMBERS;
|
|
const size_t* end = PRIME_NUMBERS + sizeof(PRIME_NUMBERS)/sizeof(*PRIME_NUMBERS);
|
|
const size_t* cur = std::lower_bound(begin, end, size_);
|
|
if (end != cur) {
|
|
Rehash(*cur);
|
|
} else {
|
|
Rehash(size_);
|
|
}
|
|
}
|
|
|
|
assert(buckets_.size() >= size_ && size_ > 0);
|
|
size_t bucketid = Hash(v.first) % buckets_.size();
|
|
bool ok = buckets_[bucketid].UniqAppend(v).second;
|
|
if (!ok) {
|
|
size_ --;
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
const_iterator Find(const KeyT& key) const {
|
|
if (size_ == 0) {
|
|
return End();
|
|
}
|
|
assert(buckets_.size() > 0);
|
|
size_t bucketid = Hash(key) % buckets_.size();
|
|
const struct LightList::Node* node = buckets_[bucketid].head_;
|
|
while (node != NULL) {
|
|
if (node->value.first == key) {
|
|
return const_iterator(bucketid, &buckets_, node);
|
|
}
|
|
node = node->next;
|
|
}
|
|
return End();
|
|
}
|
|
|
|
const_iterator Begin() const {
|
|
if (buckets_.empty()) {
|
|
return End();
|
|
}
|
|
size_t bucketid = 0;
|
|
assert(bucketid < buckets_.size());
|
|
const struct LightList::Node* node = buckets_[bucketid].head_;
|
|
while (node == NULL && bucketid < buckets_.size()) {
|
|
bucketid ++;
|
|
node = buckets_[bucketid].head_;
|
|
}
|
|
return const_iterator(bucketid, &buckets_, node);
|
|
}
|
|
const_iterator End() const {
|
|
return const_iterator(buckets_.size(), &buckets_, NULL);
|
|
}
|
|
|
|
void Rehash(size_t maxsize) {
|
|
assert(maxsize > 0);
|
|
std::vector<LightList> newbuckets(maxsize);
|
|
for (size_t i = 0; i < buckets_.size(); ++i) {
|
|
struct LightList::Node* oldnode = buckets_[i].head_;
|
|
while (oldnode != NULL) {
|
|
size_t bucketid = Hash(oldnode->value.first) % maxsize; //TODO
|
|
newbuckets[bucketid].PushFront(oldnode->value);
|
|
oldnode = oldnode->next;
|
|
}
|
|
}
|
|
buckets_.swap(newbuckets);
|
|
}
|
|
private:
|
|
size_t Hash(KeyT key) const {
|
|
return key;
|
|
}
|
|
|
|
std::vector<LightList> buckets_;
|
|
size_t size_;
|
|
}; // class HashMap
|
|
|
|
} // namespace limonp
|
|
|
|
#endif // LIMONP_HASH_MAP_HPP
|