学习hashtable

还是直接上代码吧：

#include <stdlib.h>
#include <string>
#include <iostream>
#include <fstream>
#include <vector>
#include <list>

using namespace std;

static const int hashtable_length    = 6151;
static const int hashtable_compare    = 769;

// 用于定位一个Bucket
unsigned int hash1(const char* str)
{
    const char* end_of_str = str+strlen(str);
    unsigned int sum = 0;
    while (end_of_str - str > 3)
    {
        sum = (sum + (unsigned int)*((unsigned int*)str))%hashtable_length;
        str += 4;
    }
    return sum;
}

// 用于快速比较两个字符串，理论上会提高检索速度
// 用长度来判断是一种简单的方法，有时间可以设计更复杂的方法
unsigned int hash2(const char* str)
{
    return strlen(str)%hashtable_compare;    
}
bool find_in_bucket(list<string>& l, const char* str)
{
    list<string>::iterator iter;
    unsigned int hash_key1 = hash1(str);
    unsigned int hash_key2 = hash2(str);
    bool exist = false;
    for (iter = l.begin(); iter != l.end(); iter++)
    {
        if (hash_key2 == hash2(iter->c_str()))
            if (strcmp(str, iter->c_str()) == 0)
            {
                return true;
            }
    }
    return false;
}
int insert_in_bucket(list<string>& l, const char* str)
{
    if (!find_in_bucket(l, str))
    {
        l.push_back(string(str));
        return l.size();
    }else
        return -1;
}
bool find_in_hashtable(vector<list<string>>& v, const char* str)
{
    return find_in_bucket(v[hash1(str)], str);
}
int insert_in_hashtable(vector<list<string>>& v, const char* str)
{
    return insert_in_bucket(v[hash1(str)], str);
}

int main()
{
    // 学习list
    // 学习hashtable

    vector<list<string>> hashtable(hashtable_length, list<string>());
    
    ofstream log_file;
    log_file.open("D:\log.txt");
    ifstream input_file;
    input_file.open("D:\input.txt");
    if(!input_file)
        return -1;

    // 10KB的缓冲区。注意！如果缓冲区过大，会导致栈空间不足，在函数层层调用的时候，会产生 stack overflow 错误！
    char buff[10240] = {0};    
    int max_of_bucket = -1;
    while (input_file.getline(buff, 10240-1))
    {
        // 使用哈希表，存储海量数据，能够快速查找和插入
        int len = insert_in_hashtable(hashtable, buff);
        if (len > max_of_bucket) 
            max_of_bucket = len;
        log_file<< "hashkey	= 	" << hash1(buff) << "
length	=	"<< len << "
" << endl;
    }
    log_file<< "max_of_bucket = " << max_of_bucket << endl;
    input_file.close();

    // 快速查找
    input_file.open("D:\test.txt");
    if(!input_file)
        return -2;
    while (input_file.getline(buff, 10240-1))
    {
        // 使用哈希表，存储海量数据，能够快速查找
        if (find_in_hashtable(hashtable, buff))
            log_file.write("Found it !
", strlen("Found it !
"));
        else
            log_file.write("Missed it !
", strlen("Missed it !
"));
    }
    input_file.close();
    log_file.close();

    return 0;
}