散列表/哈希表（hash table）- C++實現

散列表又稱哈希表，查找只需要花費常數時間，查找效率極高，對龐大數據的查找很有作用。

散列表解決沖突的方式有多種，這里采用了分離鏈接法，除此外還有開放地址法和雙散列。

Vocabulary類是用來儲存單詞的類，用於實現一個離線詞典的數據方案，當然這並不是最高效的方法，但是我認為是比較容易理解的方法，對於初學哈希表的人來說還是比較容易接受的。

/************************************************************************/
/* 文件說明：
/* 采用分離鏈接法實現哈希表，采用C++標准庫中的vector和list實現 
/* 
/************************************************************************/
#include <vector>
#include <list>
#include <string>

class Vocabulary;

int hash(const std::string & key, const int &tableSize);
int hash(const int & key, const int &tableSize);
//int hash(const Vocabulary & e, const int &tableSize);

namespace stl
{

    template <typename HashedObj>
    class HashTable
    {
    public:
        //typedef vector<std::list<HashedObj> >::size_type SIZE;

        HashTable(int size = 101);     //初始化哈希表的大小
        ~HashTable(){}
        bool contains(const HashedObj & obj);
        bool insert(const HashedObj & obj);
        bool remove(const HashedObj & obj);
    private:
        
        std::vector<std::list<HashedObj> > theList;   //哈希表
        int myhash(const HashedObj & obj) const;   //哈希函數
    };


    //函數定義
    template <typename HashedObj>
    HashTable<HashedObj>::HashTable(int size /*= 101*/)
    {
        /*根據哈希表的大小分配vector的空間*/
        theList.reserve(size);
        theList.resize(size);
    }

    template <typename HashedObj>
    int HashTable<HashedObj>::myhash(const HashedObj & obj) const
    {
        //根據object不同調用不同版本的hash重載函數
        return hash(obj, theList.size());
    }

/************************************************************************/
/* 函數名稱：contains
/* 函數功能：查找指定對象是否在哈希表中
/* 返回值：存在返回true，不存在返回false
/************************************************************************/
    template <typename HashedObj>
    bool HashTable<HashedObj>::contains(const HashedObj & obj)
    {
        int iHashValue = myhash(obj);
        const std::list<HashedObj> & tempList = theList[iHashValue];

        std::list<HashedObj>::const_iterator it = tempList.cbegin();

        for (; it != tempList.cend() && *it != obj; ++it);
        
        if(it != tempList.cend())
            return true;
        else
            return false;
    }

/************************************************************************/
/* 函數名稱：insert
/* 函數功能：向hash表中插入元素，如果元素已經存在則返回false，不存在則在鏈表的最前面插入
/* 返回值：成功返回true，失敗返回返回false
/************************************************************************/
    template <typename HashedObj>
    bool HashTable<HashedObj>::insert(const HashedObj & obj)
    {
        int iHashValue = myhash(obj);

        std::list<HashedObj> & tempList = theList[iHashValue];
        if (contains(obj))
        {
            return false;   //已經存在返回false
        }

        tempList.push_back(obj);
        return true;
    }

    /************************************************************************/
    /* 函數名稱：remove
    /* 函數功能：從哈希表中刪除指定元素，如果元素不存在則返回false
    /* 返回值：成功返回true，失敗返回返回false
    /************************************************************************/
    template <typename HashedObj>
    bool HashTable<HashedObj>::remove(const HashedObj & obj)
    {
        list<HashedObj> & tempList = theList[myhash(obj)];
        auto it = find(tempList.begin(), tempList.end(), obj);
        if (it == tempList.end())
        {
            return false;
        }
        tempList.erase(it);
        return true;
    }
}


//hash表中存入單詞表類，一個對象表示對應一個單詞
class Vocabulary
{
public:
    Vocabulary(){ }

    ~Vocabulary(){ }

    void SetWordName(std::string name)
    {
        m_sWord = name;
    }

    void SetWordExplain(std::string explain)
    {
        m_sExplain = explain;
    }

    const std::string getName() const
    {
        return m_sWord;
    }

    Vocabulary(const Vocabulary &vc){

    }

    Vocabulary& operator= (const Vocabulary & v)
    {
        m_sWord = v.m_sWord;
        m_sExplain = v.m_sExplain;
        return *this;
    }




private:
    std::string m_sWord;
    std::string m_sExplain;
};

bool operator== (const Vocabulary & word1, const Vocabulary & word2)
{
    if (word1.getName() == word2.getName())
    {
        return true;
    } 
    else
    {
        return false;
    }
}

bool operator!= (const Vocabulary & word1, const Vocabulary & word2) 
{
    return !(word1 == word2);
}

int hash(const Vocabulary & e,const int &tableSize)
{
    return hash(e.getName(), tableSize);
}

int hash(const std::string & key, const int &tableSize)
{
    //采用公式：h = (k1*32 + k2) * 32 + k3，將其擴展到n次多項式
    long long int hashVal = 0;
    int count = 0;
    for (auto it = key.begin(); it != key.end(); ++it) 
    {
        if (count++ % 2 == 0)
        {
            hashVal += (hashVal << 5) + *it;
        }
        
    }
    return hashVal %= tableSize;
}

int hash(const int & key, const int &tableSize)
{
    return key % tableSize;
}