Hash表的C++实现

用C++写了一个链地址型的Hash表

 

参考博客：https://blog.csdn.net/Bob__yuan/article/details/100016473， https://blog.csdn.net/weixin_38169413/article/details/81612307

 

Hash表介绍

散列技术是在记录的存储位置和他的关键字之间建立一个确定的对应关系f，是的每个关键字key对应一个存储位置f(key)。查找时，根据这个对应的关系找到给定值key的映射f(key)，若查找集合中存在这个记录，则必定在f(key)的位置上。我们把这种对应关系f成为散列函数，又称为哈希(Hash)函数。采用散列技术将记录存储在一块连续的存储空间中，这块连续空间称为散列表或哈希表(Hash-Table)。

 

Hash表的构造方法

1. 直接定址法
2. 取余法
3. 数字分析法
4. 平方取中法
5. 折叠法

本文用取余法

 

Hash表的冲突策略

1.开放地址法

一旦产生了冲突（该地址已有其它元素），就按某种规则去寻找另一空地址.若发生了第 i 次冲突，试探的下一个地址将增加d_i， 基本公式是：

这里面d_i决定了不同的解决冲突方案： **线性探测、平方探测、双散列。不赘述，参考博客2

2.链地址法

链地址法就是将相应位置上冲突的所有关键词存储在同一个单链表中。将所有关键字为同义词的记录存储在一个单链表中，这种链表叫做同义词子表，使用除留余数法，就不存在冲突的问题了，只是在链表中增加一个结点。

 

 

代码实现：将26个字母放在Hash表中，支持增删查功能，并移除字母c。

#include <iostream>
#include <map>

#define ARRAY_NUMBER 11

//用于存放数据的节点
template<typename T>
struct LNode{
  T data;
  LNode* next;

  LNode(T t, LNode* ptNext){
      data = t;
      ptNext = next;
  }
};

template<typename T>
class HashMap{
public:
    //插入元素
    void insert(T data)
    {
        long hashValue = std::hash<T>()(data);  //通过std::hash得到hash值（std::hash可以匹配多种类型）
        int hashKey = hashValue % ARRAY_NUMBER;
        LNode<T>* pNode = new LNode<T>(data, NULL);
        LNode<T>* pInsertNode = mapData[hashKey];
        if (pInsertNode == NULL)
        {
            mapData[hashKey] = pNode;
        } else {
            LNode<T>* pPreviousNode = NULL;
            while (pInsertNode != NULL) {
                pPreviousNode = pInsertNode;
                pInsertNode = pInsertNode->next;
            }
            pPreviousNode->next = pNode;
            pInsertNode = pNode;
        }
    }

    //查找一个数据
    bool find(T data)
    {
        long hashValue = std::hash<T>()(data);
        int hashKey = hashValue % ARRAY_NUMBER;
        LNode<T>* pNode =  mapData[hashKey];
        while (pNode != NULL)
        {
            if (pNode->data == data)
            {
                std::cout << "Find out data :" << pNode->data << std::endl;
                return true;
            }
            pNode = pNode->next;
        }
        std::cout << "Not found" << std::endl;
        return false;
    }

    //移除一个数据
    void remove(T data)
    {
        long hashValue = std::hash<T>()(data);
        int hashKey = hashValue % ARRAY_NUMBER;
        LNode<T>* pNode =  mapData[hashKey];
        LNode<T>* pPreviousNode = NULL;
        while (pNode != NULL)
        {
            if (pNode->data != data)
            {
                pPreviousNode = pNode;
                pNode = pNode->next;
            } else {
                if (pPreviousNode)
                {
                    pPreviousNode->next = pNode;
                } else {
                    mapData[hashKey] = pNode->next;
                    break;
                }
                if (pNode->next)
                {
                    pPreviousNode->next = pNode->next;
                }
                else
                {
                    pPreviousNode->next = NULL;
                }
                break;
            }
        }
    }

    //初始化Hash表，本例用std::map,为每个数组元素创建一个链表
    void initialize()
    {
        for (int i=0; i < ARRAY_NUMBER; i++)
        {
            mapData.insert(std::pair<int, LNode<T>*>(i, NULL));
        }
    }

    //输出Hash表
    void print()
    {
        for (int i=0; i < ARRAY_NUMBER; i++)
        {
            std::cout << i;
            LNode<T>* pNode = mapData[i];
            while (pNode) {
                std::cout << " -> " << pNode->data;
                pNode = pNode->next;
            }
            std::cout << std::endl;
        }
    }


private:
    std::map<int, LNode<T>*> mapData;

};


int main(int argc, char *argv[])
{
    HashMap<char> hashMap;
    hashMap.initialize();
    for (char c = 'a'; c <= 'z'; c++)
    {
        hashMap.insert(c);
    }
    hashMap.find('c');
    hashMap.remove('c');
    hashMap.find('c');
    hashMap.print();
    return 0;
}

输出：

Find out data :c
Not found
0 -> n -> y
1 -> d -> o -> z
2 -> e -> p
3 -> f -> q
4 -> g -> r
5 -> h -> s
6 -> i -> t
7 -> j -> u
8 -> k -> v
9 -> a -> l -> w
10 -> b -> m -> x