C++：哈希表

已于 2024-09-08 13:35:31 修改
阅读量791 收藏 30
点赞数 18
分类专栏： C++ 文章标签： c++ 算法
于 2024-07-12 10:56:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61088872/article/details/140370896
版权

哈希表概念

哈希表可以简单理解为：把数据转化为数组的下标，然后用数组的下标对应的值来表示这个数据。如果我们想要搜索这个数据，直接计算出这个数据的下标，然后就可以直接访问数组对应的位置，所以可以用O(1)的复杂度直接找到数据。

其中，这个数据对应的数字叫做关键码(Key)，这个把关键码转化为下标的规则，叫做哈希函数(Hash)。

要注意的是，有一些数据并不是整型，比如字符串，对象等等。对于这种数据，我们要先用一套规则把它们转化为整数（关键码），然后再通过哈希函数映射为数组下标。

哈希函数

哈希函数原则：

  1. 哈希函数转换后，生成的地址（下标）必须小于哈希表的最大地址（下标）
  2. 哈希函数计算出来的地址（下标）必须均匀地分布
  3. 哈希函数尽可能简单
直接定址法

取关键字的某个线性函数为哈希表的地址：

除留余数法

假设哈希表的地址数目为m，取Key对m取模后得到的值作为下标

闭散列 - 开放定址法

闭散列，也叫做开放定址法，当发生哈希冲突时，如果哈希表没有被装满，说明哈希表中还有空位置，那么我们可以把发生冲突的数据放到下一个空位置去。

基本结构

首先我们需要一个枚举，来标识哈希表的不同状态：

enum State
{
    EMPTY,
    EXIST,
    DELETE
};

EMPTY：空节点
EXIST：数值存在
DELETE：数值被删除 

哈希表的基本结构：

enum State
{
    EMPTY,
    EXIST,
    DELETE
};

template<class K, class V>
struct HashData
{
    pair<K, V> _kv;
    State _state = EMPTY;//标记状态
};

template<class K, class V>
class HashTable
{
public:
    HashTable(size_t size = 10)
    {
        _tables.resize(size);
    }

private:
    vector<HashData<K, V>> _tables;//哈希表
    size_t _n = 0;//元素个数
};

HashTable构造函数：

HashTable(size_t size = 10)
{
    _tables.resize(size);
}
查找

想要在哈希表中查找数据，无非就遵顼以下规则：

通过哈希函数计算出数据对应的地址
去地址处查找，如果地址处不是目标值，往后继续查找
遇到EMPTY还没有找到，说明数据不存在哈希表中
遇到DELETE和EXIST，继续往后查找

代码如下：

HashData<K, V>* Find(const K& key)
{
    size_t hashi = key % _tables.size();

    while (_tables[hashi]._state != EMPTY)
    {
        if (_tables[hashi]._kv.first == key
            && _tables[hashi]._state == EXIST)
            return &_tables[hashi];

        hashi++;
        hashi %= _tables.size();
    }

    return nullptr;
}

但是当前的代码存在一个问题：哈希表作用于泛型，key % _tables.size()有可能是违法的行为，因为key可能不是一个数字。

对此我们可以在模板中多加一个仿函数的参数，用户可以在仿函数中自定义数据 -> 整型的转换规则，然后我们在对这个整型使用除留余数法获取地址。

在那之前，我们可以先写一个仿函数，用于处理整型 -> 整型的转化：

struct HashFunc
{
    size_t operator()(const K& key)
    {
        return (size_t)key;
    }
};

在STL中，整型-> 整型转化的函数，被写为了一个模板，而这个string -> 整型被写为了一个模板特化：

template<class K>
struct HashFunc
{
    size_t operator()(const K& key)
    {
        return (size_t)key;
    }
};

template<>
struct HashFunc<string>
{
    size_t operator()(const string& s)
    {
        size_t hash = 0;

        for (auto& e : s)//把字符串的每一个字符ASCII码值加起来
        {
            hash += e;
            hash *= 131; // 31, 131313(任意由1，3间断排列的数字)
        }

        return hash;
    }
};

我们将这个HashFunc<K>仿函数作为哈希表的第三个模板参数的默认值：

template<class K, class V, class Hash = HashFunc<K>>
class HashTable
{};

通过仿函数来统一获得整型，再进行除留余数操作：

Hash hs;
size_t hashi = hs(key) % _tables.size();
插入

插入的基本逻辑如下：

  1. 先通过Find接口，查找目标值在不在哈希表中，如果目标值已经存在，返回flse，表示插入失败
  2. 通过哈希函数计算出目标值对应的下标
  3. 向下标中插入数据：如果下标对应的位置已经有数据，往后查找，直到某一个位置为EMPTY或者DELETE.如果下标对应的位置没有数据，直接插入
  4. 插入后，把对应位置的状态转化为EXIST

代码如下：

bool Insert(const pair<K, V>& kv)
{
    if (Find(kv.first))
        return false;

    Hash hs;//仿函数实例化出的对象
    size_t hashi = hs(kv.first) % _tables.size();//获得目标值对应的下标

    while (_tables[hashi]._state == EXIST)//往后查找合适的位置插入
    {
        hashi++;
        hashi %= _tables.size();
    }

    _tables[hashi]._kv = kv;//插入
    _tables[hashi]._state = EXIST;//改变状态
    _n++;//哈希表中的元素个数+1

    return true;
}

当这个哈希表越满，我们查找数据的效率就越低，甚至说：如果查找一个不存在的数据，我们可能要用O(N)的复杂度遍历整个哈希表.因此我们因该把哈希表的负载率控制在一定值，当超过一定值，我们就要进行扩容操作。

if ((double)_n / _tables.size() >= 0.7)
{
    size_t newSize = _tables.size() * 2;

    HashTable<K, V, Hash> newHT(newSize);

    for (auto& e : _tables)
    {
        if (e._state == EXIST)
            newHT.Insert(e._kv);
    }

    _tables.swap(newHT._tables);
}

插入总代码：

bool Insert(const pair<K, V>& kv)
{
    if (Find(kv.first))
        return false;

    if ((double)_n / _tables.size() >= 0.7)
    {
        size_t newSize = _tables.size() * 2;

        HashTable<K, V, Hash> newHT(newSize);

        for (auto& e : _tables)
        {
            if (e._state == EXIST)
                newHT.Insert(e._kv);
        }

        _tables.swap(newHT._tables);
    }

    Hash hs;
    size_t hashi = hs(kv.first) % _tables.size();

    while (_tables[hashi]._state == EXIST)
    {
        hashi++;
        hashi %= _tables.size();
    }

    _tables[hashi]._kv = kv;
    _tables[hashi]._state = EXIST;
    _n++;

    return true;
}
删除

先通过Find接口找到要删除的值

  • 如果没找到，返回false，表示删除失败
  • 如果找到，把对应节点的状态改为DELETE

最后再把哈希表的_n - 1，表示存在的节点数少了一个。

代码如下：

bool Erase(const K& key)
{
    HashData<K, V>* ret = Find(key);
    if (ret)
    {
        ret->_state = DELETE;
        _n--;
        return true;
    }

    return false;
}

总代码展示

template<class K>
struct HashFunc
{
    size_t operator()(const K& key)
    {
        return (size_t)key;
    }
};

template<>
struct HashFunc<string>
{
    size_t operator()(const string& s)
    {
        size_t hash = 0;

        for (auto& e : s)//把字符串的每一个字符ASCII码值加起来
        {
            hash += e;
            hash *= 131; // 31, 131313(任意由1，3间断排列的数字)
        }

        return hash;
    }
};

enum State
{
    EMPTY,
    EXIST,
    DELETE
};

template<class K, class V>
struct HashData
{
    pair<K, V> _kv;
    State _state = EMPTY;//标记状态
};

template<class K, class V, class Hash = HashFunc<K>>
class HashTable
{
public:
    HashTable(size_t size = 10)
    {
        _tables.resize(size);
    }

    HashData<K, V>* Find(const K& key)
    {
        Hash hs;
        size_t hashi = hs(key) % _tables.size();

        while (_tables[hashi]._state != EMPTY)
        {
            if (_tables[hashi]._kv.first == key
                && _tables[hashi]._state == EXIST)
                return &_tables[hashi];

            hashi++;
            hashi %= _tables.size();
        }

        return nullptr;
    }

    bool Insert(const pair<K, V>& kv)
    {
        if (Find(kv.first))
            return false;

        if ((double)_n / _tables.size() >= 0.7)
        {
            size_t newSize = _tables.size() * 2;

            HashTable<K, V, Hash> newHT(newSize);

            for (auto& e : _tables)
            {
                if (e._state == EXIST)
                    newHT.Insert(e._kv);
            }

            _tables.swap(newHT._tables);
        }

        Hash hs;
        size_t hashi = hs(kv.first) % _tables.size();

        while (_tables[hashi]._state == EXIST)
        {
            hashi++;
            hashi %= _tables.size();
        }

        _tables[hashi]._kv = kv;
        _tables[hashi]._state = EXIST;
        _n++;

        return true;
    }

    bool Erase(const K& key)
    {
        HashData<K, V>* ret = Find(key);
        if (ret)
        {
            ret->_state = DELETE;
            _n--;
            return true;
        }

        return false;
    }

private:
    vector<HashData<K, V>> _tables;
    size_t _n = 0;//元素个数
};
开散列 - 哈希桶

在STL库中，采用的是更加优秀的开散列方案。

哈希表的数组vector中，不再直接存储数据，而是存储一个链表的指针。当一个数值映射到对应的下标后，就插入到这个链表中。其中每一个链表称为一个哈希桶，每个哈希桶中，存放着哈希冲突的元素.

基本结构

对于每一个节点，其要存储当前节点的值，也要存储下一个节点的指针，基本结构如下：

template<class K, class V>
struct HashNode
{
    HashNode<K, V>* _next;
    pair<K, V> _kv;

    HashNode(const pair<K, V>& kv)
        :_kv(kv)
        ,_next(nullptr)
    {}
};

哈希表：

template<class K, class V, class Hash = HashFunc<K>>
class HashTable
{
    typedef HashNode<K, V> Node;
public:
    HashTable(size_t size = 10)
    {
        _tables.resize(size);
    }
    
private:
    vector<Node*> _tables; //链表指针数组
    size_t _n = 0;//元素个数
};

析构函数，防止内存泄漏：

~HashTable()
{
    for (size_t i = 0; i < _tables.size(); i++)
    {
        Node* cur = _tables[i];
        while (cur)
        {
            Node* next = cur->_next;
            delete cur;
            cur = next;
        }
        _tables[i] = nullptr;
    }
}
查找

查找的基本逻辑如下：

  1. 先通过哈希函数计算出数据对应的下标
  2. 通过下标找到对应的链表
  3. 遍历链表，找数据:如果某个节点的数据匹配上了，返回该节点指针,如果遍历到了nullptr，返回空指针表示没找到

代码如下：

Node* Find(const K& key)
{
    Hash hs;
    size_t hashi = hs(key) % _tables.size();

    Node* cur = _tables[hashi];
    while (cur)
    {
        if (cur->_kv.first == key)
            return cur;

        cur = cur->_next;
    }

    return nullptr;
}
插入

插入的基本逻辑如下：

  1. 先通过Find接口，查找目标值在不在哈希表中，如果目标值已经存在，返回flse，表示插入失败
  2. 通过哈希函数计算出目标值对应的下标
  3. 向下标中插入数据

代码如下：

bool Insert(const pair<K, V>& kv)
{
    if (Find(kv.first))
        return false;

    Hash hs;
    size_t hashi = hs(kv.first) % _tables.size();//计算下标
    Node* newNode = new Node(kv);//创建节点

    newNode->_next = _tables[hashi];//头插
    _tables[hashi] = newNode;

    ++_n;//更新元素个数
    return true;
}

关于扩容:如果我们单纯的进行插入，就要把原先的所有节点释放掉，再创建新的节点。这样会浪费很多时间。我们最好把原先创建的节点利用起来，因此我们要重写一个逻辑，把原先的节点进行迁移。 

if (_n == _tables.size())
{
    vector<Node*> newTables(_tables.size() * 2, nullptr);
    for (size_t i = 0; i < _tables.size(); i++)
    {
        Node* cur = _tables[i];
        while (cur)
        {
            Node* next = cur->_next;

            size_t hashi = hs(cur->_kv.first) % newTables.size();
            cur->_next = newTables[hashi];
            newTables[hashi] = cur;

            cur = next;
        }

        _tables[i] = nullptr; //防止移交的节点被析构
    }

    _tables.swap(newTables);
}
删除

删除逻辑：

  1. 通过哈希函数计算出对应的下标
  2. 到对应的哈希桶中查找目标值
  • 如果找到，删除对应的节点
  • 如果没找到，返回false表示删除失败
  • _n - 1表示删除了一个元素

代码如下：

bool Erase(const K& key)
{
    Hash hs;
    size_t hashi = hs(key) % _tables.size();

    Node* prev = nullptr;
    Node* cur = _tables[hashi];
    while (cur)
    {
        if (cur->_kv.first == key)
        {
            if (prev)
                prev->_next = cur->_next;
            else
                _tables[hashi] = cur->_next;

            delete cur;
            --_n;
            return true;
        }

        prev = cur;
        cur = cur->_next;
    }

    return false;
}

代码展示

template<class K>
struct HashFunc
{
    size_t operator()(const K& key)
    {
        return (size_t)key;
    }
};

template<>
struct HashFunc<string>
{
    size_t operator()(const string& s)
    {
        size_t hash = 0;

        for (auto& e : s)//把字符串的每一个字符ASCII码值加起来
        {
            hash += e;
            hash *= 131; // 31, 131313(任意由1，3间断排列的数字)
        }

        return hash;
    }
};

template<class K, class V>
struct HashNode
{
    HashNode<K, V>* _next;
    pair<K, V> _kv;

    HashNode(const pair<K, V>& kv)
        :_kv(kv)
        ,_next(nullptr)
    {}
};

template<class K, class V, class Hash = HashFunc<K>>
class HashTable
{
    typedef HashNode<K, V> Node;
public:
    HashTable(size_t size = 10)
    {
        _tables.resize(size);
    }

    ~HashTable()
    {
        for (size_t i = 0; i < _tables.size(); i++)
        {
            Node* cur = _tables[i];
            while (cur)
            {
                Node* next = cur->_next;
                delete cur;
                cur = next;
            }
            _tables[i] = nullptr;
        }
    }

    Node* Find(const K& key)
    {
        Hash hs;
        size_t hashi = hs(key) % _tables.size();

        Node* cur = _tables[hashi];
        while (cur)
        {
            if (cur->_kv.first == key)
                return cur;

            cur = cur->_next;
        }

        return nullptr;
    }

    bool Insert(const pair<K, V>& kv)
    {
        if (Find(kv.first))
            return false;

        Hash hs;

        //哈希桶情况下，负载因子到1才扩容
        if (_n == _tables.size())
        {
            vector<Node*> newTables(_tables.size() * 2, nullptr);
            for (size_t i = 0; i < _tables.size(); i++)
            {
                Node* cur = _tables[i];
                while (cur)
                {
                    Node* next = cur->_next;

                    size_t hashi = hs(cur->_kv.first) % newTables.size();
                    cur->_next = newTables[hashi];
                    newTables[hashi] = cur;

                    cur = next;
                }

                _tables[i] = nullptr; //防止移交的节点被析构
            }

            _tables.swap(newTables);
        }

        size_t hashi = hs(kv.first) % _tables.size();
        Node* newNode = new Node(kv);

        newNode->_next = _tables[hashi];
        _tables[hashi] = newNode;

        ++_n;
        return true;
    }

    bool Erase(const K& key)
    {
        Hash hs;
        size_t hashi = hs(key) % _tables.size();

        Node* prev = nullptr;
        Node* cur = _tables[hashi];
        while (cur)
        {
            if (cur->_kv.first == key)
            {
                if (prev)
                    prev->_next = cur->_next;
                else
                    _tables[hashi] = cur->_next;

                delete cur;
                --_n;
                return true;
            }

            prev = cur;
            cur = cur->_next;
        }

        return false;
    }

private:
    vector<Node*> _tables; //链表指针数组
    size_t _n = 0;//元素个数
};

凤 曦
关注
专栏目录
C++实现哈希表。
TPON的博客
11-17 6571
C++模拟实现哈希表
中级C++：哈希
kimsaul的白给岁月
06-29 486
闭散列、闭散列、封装成unorder_map、unorder_set
Hash表（C++实现）
lovecontry
08-20 451
哈希表的几个概念： 映像：由哈希函数得到的哈希表是一个映像。 冲突：如果两个关键字的哈希函数值相等，这种现象称为冲突。 处理冲突的几个方法： 1、开放地址法：用开放地址处理冲突就是当冲突发生时，形成一个地址序列，沿着这个序列逐个深测，直到找到一个“空”的开放地址，将发生冲突的关键字值存放到该地址中去。 例如：hash(i)=(hash(key)+d(i)) MOD m (i=1,2,3,...
【C++】哈希表
m0_74808907的博客
06-30 1930
一文带你由浅入深掌握哈希表
c++ 哈希表（hash表）
diaoxiangxi0422的博客
02-19 249
一、定义 Hash表，也称散列表。一般应用于有大量“动态”的插入(删除)和查找操作的一类问题。（如果是“静态”的，通常可以先对数据排序，查找时就可以用“二分查找”） 虽然可以用“平衡树”之类方法，但实践中，用hash表更简单实用。 普通的查找方法建立在“比较”的基础上，查找的效率与比较次数密切相关。 hash的思想是能直接...
C++哈希表
qq_33287871的博客
08-24 875
数据结构-哈希表原理详解1.什么是哈希表2.哈希表原理3.c++中哈希表接口的使用 1.什么是哈希表 散列表(Hash table 也叫哈希表)，是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 2.哈希表原理 给定表M，存在函数f(key)，对任意给定的关键字key，代入函数后若能得到包含关键字的记录在表中的地址，则称表M为哈希表(Hash Table)，函数f(key
C++实现哈希表
Ly的博客
05-28 2862
本文主要是对哈希表这种数据结构进行介绍。含义是根据存储的值和存储的位置建立映射关系从而快速检索查找存储的数据，哈希表是一种非常高效的数据结构。本文会用C++介绍哈希表的相关实现。
C++ 实现哈希表的实例
08-29
C++ 实现哈希表的实例详解 哈希表是一种常用的数据结构，它可以快速地...通过了解哈希表的基本概念、C++ 实现哈希表的实例代码实现、哈希表的实现机制和哈希表的应用场景，我们可以更好地应用哈希表来解决实际问题。
C++:数组、链表与哈希表
sinat_40628756的博客
12-04 2608
自我介绍一下个人情况：我对C++属于初学者，没有做过C++写的项目，只在菜鸟教程粗略过了一遍C++的基本概念。我刷题准备用的是C++语言，打算分类刷题，每次刷题前我都会补习相应的C++知识，顺便在此记录。 文章目录数组和链表数组什么是数组？访问数组元素可变长的动态数组：vectorVector基本用法链表什么是链表？链表的操作双向链表（list）list的成员函数总结 数组和链表 C++的数组和链表分别是什么？分别有什么种类？它们都有什么特性？针对这些特征，使用情形是什么？ 数组 什么是数组？
C++源代码：哈希表算法
06-28
以上就是一个基础的C++哈希表实现，可以根据具体需求扩展哈希函数和冲突解决策略。理解哈希表的工作原理和C++中的实现方式，对于提升程序性能和优化数据结构设计都具有重要意义。在实际编程中，可以灵活运用`std::...
『数据结构』哈希表
叄拾叄画生
08-05 6883
什么是哈希？哈希冲突。哈希函数。哈希冲突解决方法。闭散列（线性探测、二次探测）。开散列（哈希桶）、开散列模拟实现（C++和Java）。
一个c++实现的哈希表类
06-27
在程序中我们对关键字key应用散列函数H(key)来判断关键字key是否在散列表中，即计算H(key)的值，H(key)值确定所存数据在散列表中的位置。这样一个数据元素的地址是通过函数来计算的，所以数据元素并不需要按照特定的顺序来存放。但是散列函数H(key)将关键字映射为一个整数时，有可能两个关键字的地址相同，所以构造散列函数时要考虑尽量减少冲突的发生。构造散列函数有多种方法，如：平方取中法、除留余数随机数法。本程序采用除留余数法。程序的具体实现如下：本程序是用模板类myhash来实现，包括protected和public属性成员。其中protected成员有*ht（自定义散列表指针）、*empty(bool类型指针，功能是将元素值空、m(散列表容量)、p(除留余数法的除数)以及辅助函数H(key)(散列函数)和collision(处理冲突的函数)；public成员包括构造函数、析构函数和复制构造函数以及=重载函数，其它成员函数主要有：traver(遍历散列表)、show()(打印出哈希表所存的元素)返回值为bool类型的函数search\insert\Delete。search函数（查询关键字为key的元素的位值）、insert函数(插入元素e到哈希表中)、Delete函数（删除关键字为key的元素）。本程序的main函数同样采用两种类型的数据来进行测试，int型和char型，主要测试元素的插入、删除和搜索。
C++ 哈希表
GreedySnaker的博客
02-22 4620
一 哈希表的基本介绍: 散列表( Hash table,也叫哈希表)是根据关键码值(key value)而直接进行访问的数据结构。也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。这个映射函数叫做散列函数,存放记录的数组叫做散列表。 那么他是如何映射的呢，就是通过哈希函数(散列函数)，常用的有取余法(h(x)= x mod p)，线性函数(h(x) = ax+b)，平方取中法(h(x = x*x的中间几位))。 好理解的取余法如下图。 先看左上方的表，它以53取余，所以55，2，1
哈希表的C++实现
蒻菜_羊羊羊的专栏
04-06 467
#include using namespace std; typedef int KeyType; //设关键字域为整形,需要修改类型时，只需修改这里就可以 const int NULLKEY=0; //NULLKEY表示该位置无值 int c=0; //用来统计冲突次数 struct Elemtype //
哈希表(C++实现)
最新发布
m0_50655389的博客
07-01 1477
可以不经过任何比较，一次直接从表中得到要搜索的元素
C++ hash table 的编程实现
a130737的专栏
08-21 8776
关于Hash Table， 总结如下：
C++哈希表实现
Code is to be happy
12-18 931
#include #include #include #define HASHLENGTH 10 struct node { int data; struct node *next; }; struct node hash[HASHLENGTH]; typedef struct node * HashNode; int Hash(int k) { return k%HASHLENGTH
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值