hashtable

参考《stl源码剖析》，用开链法实现了简易hash表，并进行了简单测试。

特点：

1. hash表可扩容。当元素个数大于hash表长的时候，hash表挑选下一个质数，扩容一倍。

2. 提供了hash函数以及equal函数的载入

3. 提供find，insert，erase三个基本操作。

    find返回某一元素的指针

    insert可选择不重复插入或可重复插入

    erase可选择删除一个元素或所有元素

4. 省略了迭代器，静态数组未封装在类内

#include <bits/stdc++.h>
using namespace std;

namespace ht {
    const  int _num_prime = 22;
    static const int prime_list[_num_prime] = {
        53,         97,           193,         389,       769,
        1543,       3079,         6151,        12289,     24593,
        49157,      98317,        196613,      393241,    786433,
        1572869,    3145739,      6291469,     12582917,  25165843,
        50331653,   100663319 
    };

    template<class Value>
    struct hashtable_node {
        Value val;
        hashtable_node *next;
        hashtable_node(Value val, hashtable_node *next):val(val), next(next){}
    };
    /*
    template<class Key>
    struct hashtable_iterator {
        typedef hashtable_node<Key> node;
        node *cur;
    };
    */
    template<class Key, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>>
    struct hashtable{
        typedef hashtable_node<Key> node;
        
        Hash hash;
        KeyEqual equals;
        
        vector<node*> buckets;
        int num_elements;

        hashtable(int n = *prime_list){
            num_elements = 0;
            int n_buckets = next_size(n);
            buckets.resize(n_buckets);
        }
        ~hashtable(){
            for(auto cur: buckets) {
                while(cur != NULL) {
                    node *tmp = cur->next;
                    delete cur;
                    cur = tmp;
                }
            }
        }

        node* find(const Key& obj) {
            int n = hash(obj)%buckets.size();
            node *cur = buckets[n];
            while(cur) { 
                if (equals(cur->val, obj)) 
                    return cur; 
                cur = cur->next;
            }
            return cur;
        }    
        
        pair<node*, bool> insert(const Key& obj, bool same = false) {
            resize(num_elements + 1);
            const int n = hash(obj)%buckets.size();
            node *first = buckets[n], *tmp = NULL;
            if(same || (tmp = find(obj)) == NULL) {
                tmp = new node(obj, first);
                buckets[n] = tmp;
                ++num_elements;
                return {tmp, true};
            }
            return {tmp, false};
        }

        bool erase(const Key& obj, bool same = false) {
            if(find(obj) == NULL) return false;        
            int n = hash(obj)%buckets.size();
            node **cur = &buckets[n];
            while(*cur) {
                if(equals((**cur).val, obj)) {
                    node *tmp = *cur;
                    *cur = tmp->next;
                    delete tmp;
                    --num_elements;
                    if(!same) break ;
                }
                else cur = &(**cur).next;
            }        
            return true;
        }
        
        void debug() {
            puts("debug...");
            bool tag = false;
            for(auto cur: buckets) {
                tag = false;
                while(cur) {
                    tag = true;
                    printf("%d ", cur->val);
                    cur = cur->next;
                }
                if(tag) puts("");
            }
            puts("end debug...");
        }

    private:
        int next_size(int n) {
            const int *last = prime_list+_num_prime;
            const int *pos = lower_bound(prime_list, last, n);
            return pos == last? *(last-1) : *pos;
        }
        void resize(int num) {
            int old_n = buckets.size();
            if(num > old_n){
                int n = next_size(num);
                if(n > old_n){
                    vector<node*> tmp(n, NULL);
                    for(int bucket = 0; bucket < old_n; ++bucket){
                        node *first = buckets[bucket];
                        while(first){
                            int new_bucket = hash(first->val)%n;
                            buckets[bucket] = first->next;
                            first->next = tmp[new_bucket];
                            tmp[new_bucket] = first;
                            first = buckets[bucket];
                        }
                    }
                    buckets.swap(tmp);
                }
            }
        }
    };
}

int main() {
    ht::hashtable<int> H;
    
    H.insert(3);
    H.insert(3, true);
    H.insert(3, true);
    H.insert(3, true);
    H.insert(3);
    H.debug();
    printf("%d
", H.erase(3));
    H.debug();

    auto p = H.find(3);
    printf("%d
",p? p->val: (int)p);
    printf("%d
", H.erase(3, true));

    p = H.find(3);
    printf("%d
",p? p->val: (int)p); 

    H.insert(3);
    H.insert(3, true);
    H.insert(3, true);
    H.insert(3);

    H.insert(5);
    H.insert(5);
    H.debug();
    p = H.find(5);
    printf("%d
",p? p->val: (int)p);

    printf("%d
", H.erase(5));
    printf("%d
", H.erase(3));
    p = H.find(5);
    printf("%d
",p? p->val: (int)p);
    H.debug();
    return 0;
}