C++复习之HashTable的简单实现

class hashtable {
public:
//  构造函数， n 为想要构造的 hashtable 的 bucket 数量
hashtable(size_t n);
~hashtable();
//  插入元素。若元素不存在，插入成功返回 true ；若元素已存在则插入失败，返回 false
bool insert(const int val);
//  查找元素是否在表中出现
bool find(const int val);
//  删除元素。若元素存在，删除成功返回 true ；若元素不存在则删除失败，返回 false
bool erase(const int val);
//  清除所有元素
void clear();
//  返回已有元素数目
size_t size();
private:
// bucket 中的节点
struct hashtable_node {
hashtable_node *next;
int val;
hashtable_node(int _val, hashtable_node *_next = NULL) :
val(_val), next(_next) {
}
};

hashtable(const hashtable & h); //  暂时不允许拷贝和赋值
const hashtable & operator =(const hashtable & h);
// hash 函数
size_t hash(unsigned long x);
//  寻找大于等于 n 且最接近 n 的质数
unsigned long next_prime(unsigned long n);
// bucket 向量表
vector<hashtable_node*> buckets;
//  元素个数
size_t num_elements;
};
hashtable::hashtable(size_t n) {
//  将 bucket 数量设置为大于等于 n 且最接近 n 的质数
const size_t n_buckets = next_prime(n);
buckets.reserve(n_buckets);
buckets.insert(buckets.end(), n_buckets, NULL);
num_elements = 0;
};
hashtable::~hashtable() {
//  清除所有链中的节点
clear();
}
bool hashtable::insert(const int val) {
//  不重复插入。已存在，返回 false
if (find(val))
return false;
//  调用 hash 函数获得 bucket 号
const size_t k = hash(val);
//  将新节点直接插入到链表头部
hashtable_node * tmp = new hashtable_node(val);
tmp->next = buckets[k];
buckets[k] = tmp;
++num_elements;
//  插入成功
return true;
}
bool hashtable::find(const int val) {
const size_t k = hash(val);
hashtable_node *p = buckets[k];
//  在对应的 bucket 中查找
while (p != NULL) {
if (p->val = val)
return true;
p = p->next;
}
return false;
}
bool hashtable::erase(const int val) {
const size_t k = hash(val);
hashtable_node *p = buckets[k];
hashtable_node *pre = NULL;
//  找到该节点
while (p != NULL && p->val != val) {
pre = p;
p = p->next;
}
//  删除该节点
if (p == NULL)
return false;
if (pre == NULL)
buckets[k] = p->next; // 删除第一个节点
else
pre->next = p->next;
delete p;
return true;
}
void hashtable::clear() {
//  清除所有链中的节点
for (int i = 0; i < buckets.size(); i++) {
hashtable_node *p = buckets[i];
while (p != NULL) {
hashtable_node *next = p->next;
delete p;
p = next;
}
}
}
size_t hashtable::size() {
return num_elements;
}
size_t hashtable::hash(unsigned long x) {
return x % buckets.size();
}
unsigned long hashtable::next_prime(unsigned long n) {
static const int num_primes = 28;
static const unsigned long prime_list[num_primes] = { 53, 97, 193, 389, 769,
1543, 3079, 6151, 12289, 24593, 49157, 98317, 196613, 393241,
786433, 1572869, 3145739, 6291469, 12582917, 25165843, 50331653,
100663319, 201326611, 402653189, 805306457, 1610612741,
3221225473ul, 4294967291ul };
//  寻找大于等于 n 且最接近 n 的质数
int i = 0;
while (i < num_primes && prime_list[i] < n)
i++;
return i == num_primes ? prime_list[num_primes - 1] : prime_list[i];
}
// 如果是含头结点的情况
bool hashtable::erase(const int val) {
const size_t k = hash(val);
hashtable_node *p = buckets[k];
hashtable_node *tmp = NULL;
//  找到该节点
while (p->next != NULL && p->next->val != val) {
p = p->next;
}
if (p->next == NULL)
return false;
//  删除该节点
tmp = p->next;
p->next = tmp->next;
delete tmp;
return true;
}