2022-03-02 哈希map（C++实现）

最新推荐文章于 2024-06-30 13:08:33 发布
最新推荐文章于 2024-06-30 13:08:33 发布
阅读量771 收藏
点赞数
分类专栏： 笔记 文章标签： c++ 算法 哈希算法 散列表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54206076/article/details/123228882
版权

哈希map比红黑树好实现，查找速度也更快，只是顺序查找效率低下。

哈希map的精髓是一个好用，简单，分布均匀的hash函数，《算法4》中的实现是除留余数法，本文基于此种方法实现的哈希map。

此种方法的精髓是选择合适的除数，通常它应该是质数。如果不是质数，那么当被除数与除数含有公约数，当约去公约数，最后剩下一个小质数，此时哈希表下标只能用这个小质数，也就不能均匀分散了。

常用质数：

        //  17, 31, 53, 97, 193, 389, 769,
        //  1543, 3079, 6151, 12289, 24593,
        //  49157, 98317, 196613, 393241, 786433,
        //  1572869, 3145739, 6291469, 12582917, 25165843,
        //  50331653, 100663319, 201326611, 402653189, 805306457,
        //  1610612741, 3221225473, 4294967291

下面拉链法的哈希map代码没有给出自动扩充的实现，需要知道最终插入元素的数量，自己给出构造参数中的质数。

#ifndef SEPARATECHAINNINGHASHST
#define SEPARATECHAINNINGHASHST

#include <vector>
#include <functional>

namespace ST
{
    template <typename K, typename V>
    struct listST;

    template <typename K, typename V>
    struct listNode
    {
    public:
        listNode(const K &keys, const V &vals, listNode *nexts)
            : key(keys), val(vals), next(nexts) {}

    private:
        K key;
        V val;
        listNode *next = nullptr;
        friend listST<K, V>;
    };

    template <typename K, typename V>
    struct listST
    {
    public:
        listST() = default;

        listST(const listST &rhs)
        {
            listNode<K, V> *x = rhs.first;
            while (x)
            {
                first = new listNode<K, V>(x->key, x->val, first);
                x = x->next;
            }
            sizeNum = rhs.sizeNum;
        }

        listST &operator=(const listST &rhs)
        {
            if (rhs.first && first != rhs.first)
            {
                while (first)
                {
                    listNode<K, V> *temp = first;
                    first = first->next;
                    delete temp;
                }
                listNode<K, V> *x = rhs.first;
                while (x)
                {
                    first = new listNode<K, V>(x->key, x->val, first);
                    x = x->next;
                }
                sizeNum = rhs.sizeNum;
                return *this;
            }
        }

        ~listST()
        {
            while (first)
            {
                listNode<K, V> *temp = first;
                first = first->next;
                delete temp;
            }
        }

        std::pair<bool, V> get(const K &keys);

        bool contains(const K &key);

        void del(const K &key);

        void put(const K &keys, const V &vals);

        std::size_t size() { return sizeNum; }

        std::vector<K> keyVec(); //表中所有键的集合，已排序

        std::vector<K> unOrderKeyVec(); //表中所有键的集合，已排序

    private:
        listNode<K, V> *first = nullptr;

        std::size_t sizeNum = 0;
    };

    template <typename K, typename V>
    std::pair<bool, V> listST<K, V>::get(const K &keys)
    {
        listNode<K, V> *x = first;
        while (x)
        {
            if (x->key == keys)
            {
                return std::pair<bool, V>(true, x->val);
            }
            x = x->next;
        }
        return std::pair<bool, V>(false, V());
    }

    template <typename K, typename V>
    bool listST<K, V>::contains(const K &keys)
    {
        listNode<K, V> *x = first;
        while (x)
        {
            if (x->key == keys)
            {
                return true;
            }
            x = x->next;
        }
        return false;
    }

    template <typename K, typename V>
    void listST<K, V>::del(const K &keys)
    {
        if (!first)
        {
            return;
        }
        if (first->key == keys)
        {
            listNode<K, V> *x = first;
            first = first->next;
            delete x;
            x = nullptr;
            --sizeNum;
            return;
        }
        listNode<K, V> *x = first;
        while (x->next)
        {
            if (x->next->key == keys)
            {
                listNode<K, V> *xNext = x->next;
                x->next = x->next->next;
                delete xNext;
                xNext = nullptr;
                --sizeNum;
                return;
            }
            x = x->next;
        }
    }

    template <typename K, typename V>
    void listST<K, V>::put(const K &keys, const V &vals)
    {
        listNode<K, V> *x = first;
        while (x)
        {
            if (x->key == keys)
            {
                x->val = vals;
                return;
            }
            x = x->next;
        }
        first = new listNode<K, V>(keys, vals, first);
        ++sizeNum;
    }

    template <typename K, typename V>
    std::vector<K> listST<K, V>::keyVec()
    {
        std::vector<K> veck;
        veck.reserve(sizeNum);
        listNode<K, V> *x = first;
        while (x)
        {
            veck.push_back(x->key);
            x = x->next;
        }
        std::sort(veck.begin(), veck.end());
        return veck;
    }

    template <typename K, typename V>
    std::vector<K> listST<K, V>::unOrderKeyVec()
    {
        std::vector<K> veck;
        veck.reserve(sizeNum);
        listNode<K, V> *x = first;
        while (x)
        {
            veck.push_back(x->key);
            x = x->next;
        }
        return veck;
    }

    template <typename K, typename V>
    struct HashST
    {
    public:
        HashST(std::size_t num)
            : M(num), N(0)
        {
            st = std::vector<listST<K, V>>(M);
        }

        std::pair<bool, V> get(const K &keys)
        {
            return st[hashNum(keys)].get(keys);
        }

        bool contains(const K &keys)
        {
            return st[hashNum(keys)].contains(keys);
        }

        void put(const K &keys, const V &vals)
        {
            std::size_t chainN = st[hashNum(keys)].size();
            st[hashNum(keys)].put(keys, vals);
            if (chainN < st[hashNum(keys)].size())
            {
                ++N;
            }
        }

        void del(const K &keys)
        {
            std::size_t chainN = st[hashNum(keys)].size();
            st[hashNum(keys)].del(keys);
            if (chainN > st[hashNum(keys)].size())
            {
                --N;
            }
        }

        std::vector<K> keyVec()
        {
            std::vector<K> keysVec;
            keysVec.reserve(N);
            for (std::size_t i = 0; i != M; ++i)
            {
                auto temp = st[i].unOrderKeyVec();
                if (!temp.empty())
                {
                    keysVec.insert(keysVec.end(), temp.begin(), temp.end());
                }
            }
            std::sort(keysVec.begin(), keysVec.end());
            return keysVec;
        }

    private:
        std::size_t hashNum(const K &keys)
        {
            return std::hash<K>()(keys) % M;
        }

        std::vector<listST<K, V>> st;
        std::size_t N = 0;
        std::size_t M = 1;
    };

} // namespace ST

#endif

基于线性探测法实现的哈希map给出了自动变长的实现，需要注意，自动变长是需要代价的，如果一开始就知道最终的大小K，可以直接设置哈希表的构造参数为 2K，会自动匹配合适的质数大小。

#ifndef LINEARPROBINGHASHST
#define LINEARPROBINGHASHST

#include <vector>

namespace ST
{
    template <typename K, typename V>
    struct LPHashST
    {
    public:
        LPHashST()
        {
            keysVec = std::vector<std::pair<bool, K>>(M, {false, K()});
            valsVec = std::vector<V>(M);
        }

        LPHashST(std::size_t num)
        {
            for (int i = 0; i != 30; ++i)
            {
                if (primeList[i] >= num)
                {
                    M = primeList[i];
                    break;
                }
            }
            keysVec = std::vector<std::pair<bool, K>>(M, {false, K()});
            valsVec = std::vector<V>(M);
        }

        void put(const K &keys, const V &vals)
        {
            if (N >= M / 2)
            {
                resize(M + 1);
            }
            std::size_t i = 0;
            for (i = hashNum(keys); keysVec[i].first == true; i = (i + 1) % M)
            {
                if (keysVec[i].second == keys)
                {
                    valsVec[i] = vals;
                    return;
                }
            }
            keysVec[i] = {true, keys};
            valsVec[i] = vals;
            ++N;
        }

        std::pair<bool, V> get(const K &keys)
        {
            for (std::size_t i = hashNum(keys); keysVec[i].first == true; i = (i + 1) % M)
            {
                if (keysVec[i].second == keys)
                {
                    return std::pair<bool, V>{true, valsVec[i]};
                }
            }
            return {false, V()};
        }

        bool contains(const K &keys)
        {
            for (std::size_t i = hashNum(keys); keysVec[i].first == true; i = (i + 1) % M)
            {
                if (keysVec[i].second == keys)
                {
                    return true;
                }
            }
            return false;
        }

        void del(const K &keys)
        {
            if (!contains(keys))
            {
                return;
            }
            std::size_t i = hashNum(keys);
            while (keys != keysVec[i].second)
            {
                i = (i + 1) % M;
            }
            keysVec[i].first = false;
            i = (i + 1) % M;
            while (keysVec[i].first)
            {
                K keyToRedo = keysVec[i].second;
                V valToRedo = valsVec[i];
                keysVec[i].first = false;
                --N;
                put(keyToRedo, valToRedo);
                i = (i + 1) % M;
            }
            --N;
            if (N >= 17 && N <= M / 8)
            {
                for (int i = 0; i != 30; ++i)
                {
                    if (primeList[i] >= M)
                    {
                        resize(primeList[i - 1]);
                        break;
                    }
                }
            }
        }

        std::vector<K> keyVec()
        {
            std::vector<K> temp;
            temp.reserve(N + 1);
            for (auto &&i : keysVec)
            {
                if (i.first)
                {
                    temp.push_back(i.second);
                }
            }
            return temp;
        }

    private:
        std::size_t hashNum(const K &keys)
        {
            return std::hash<K>()(keys) % M;
        }

        void resize(std::size_t cap)
        {
            LPHashST t(cap);
            for (std::size_t i = 0; i != M; ++i)
            {
                if (keysVec[i].first)
                {
                    t.put(keysVec[i].second, valsVec[i]);
                }
            }
            keysVec = t.keysVec;
            valsVec = t.valsVec;
            M = t.M;
        }

        std::size_t N = 0;
        std::size_t M = 17;
        std::vector<std::pair<bool, K>> keysVec;
        std::vector<V> valsVec;

        static const std::vector<std::size_t> primeList;
        //  17, 31, 53, 97, 193, 389, 769,
        //  1543, 3079, 6151, 12289, 24593,
        //  49157, 98317, 196613, 393241, 786433,
        //  1572869, 3145739, 6291469, 12582917, 25165843,
        //  50331653, 100663319, 201326611, 402653189, 805306457,
        //  1610612741, 3221225473, 4294967291
    };

    template <typename K, typename V>
    const std::vector<std::size_t> ST::LPHashST<K, V>::primeList =
        {17, 31, 53, 97, 193, 389, 769, 1543, 3079, 6151, 12289, 24593,
         49157, 98317, 196613, 393241, 786433, 1572869, 3145739, 6291469,
         12582917, 25165843, 50331653, 100663319, 201326611, 402653189,
         805306457, 1610612741, 2610612741, 4294967291};

} // namespace ST

#endif
不停感叹的老林_<C 语言编程核心突破>
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c++ HashMap
有趣的人
11-08 5005
HashMap map用法总结 hashmap简单介绍 #include< map> 数据结构 基于哈希表，以空间换时间，是存储key-value键值对的集合。 基本原理：使用一个下标范围比较大的数组来存储元素。可以设计一个函数（哈希函数，也叫做散列函数），使得每个元素的关键字都与一个函数值（即数组下标，hash值）相对应，于是用这个数组单元来存储这个元素；也可以简单的理解为，按照关键...
hashmap的C++实现
weixin_33692284的博客
09-02 243
hashmap的C++实现 按照hashmap的基本原理用C++实现了简单的基本功能，复杂的实现参考C++库的源码，C++最新的标准库里已经有以下四种基于hashtable的容器： unordered_set (C++11) unordered_multiset (C++11) unordered_map (C++11) unordered_multimap (C++11)。具体参考：http...
【C++】哈希表
最新发布
m0_74808907的博客
06-30 1467
一文带你由浅入深掌握哈希表
C++ STL中哈希表 hash_map从头到尾详细介绍
热门推荐
susandebug
06-26 7万+
0 为什么需要hash_map 用过map吧？map提供一个很常用的功能，那就是提供key-value的存储和查找功能。例如，我要记录一个人名和相应的存储，而且随时增加，要快速查找和修改： 岳不群－华山派掌门人，人称君子剑 张三丰－武当掌门人，太极拳创始人 东方不败－第一高手，葵花宝典 ... 这些信息如果保存下来并不复杂，但是找起来比较麻烦。例如我要找"张三丰"的信
C++模拟实现HashMap
navy专栏
12-30 778
#ifndef _HASHMAP_H #define _HASHMAP_H template<class Key, class Value> class HashNode { public: Key _key; Value _value; HashNode *next; HashNode(Key key, Value value) { _key = key; _value = value; next = ...
哈希表-使用C++实现的哈希表-HashTable.zip
03-04
在C++中，虽然标准库没有直接提供哈希表的实现，但我们可以自定义实现或者使用STL中的`std::unordered_map`或`std::unordered_set`来实现类似的功能。下面将详细介绍哈希表的工作原理、哈希冲突解决方法以及如何使用...
一个内存高效哈希映射和哈希集的c++实现- Tessil/sparse-map
01-27
《C++实现内存高效的哈希映射与哈希集——Tessil/sparse-map解析》 在计算机科学中，数据结构是编程的基础，哈希映射（HashMap）和哈希集（HashSet）作为常用的数据结构，被广泛应用于各种场景，如数据库索引、缓存...
哈希表-使用C++实现的分布式哈希表.zip
03-04
此外，C++标准库并不包含内置的哈希表实现，但你可以使用STL中的`std::unordered_map`，它提供了一种高效的哈希表实现。当然，你也可以自定义哈希函数和冲突解决策略以适应分布式环境。 为了实现分布式哈希表，你...
c++实现一个快速哈希映射和哈希集使用robin hood哈希- Tessil/robin-map
01-27
Tessil的robin-map项目提供了一个C++实现，它基于高效的Robin Hood哈希算法。下面将详细讨论这个实现以及相关的知识点。 首先，让我们了解哈希映射和哈希集的基本概念。哈希映射是一种存储键值对的数据结构，通过...
算法（42）-数组等值切割-前缀累加和-哈希表Map-set版-C++
01-07
题目：给定正整数，返回该数组能不能分成4... set和map两种哈希表类型。其实没啥本质差别。 1.unordered_set版   bool canSplits_set(vci arr) { if (arr.size() < 7) { return false; } unordered_set m
c++中的hash_map
qq_36276431的博客
05-14 5829
c++中的hash_maphash相关哈希函数哈希表c++中的hash_map 最近刷左神算法，hash_map经常被用到(hash_map的增删改查时间复杂度都能低至O(1))。但是左神用的都是java中的hash_map，苦于这个原因，只能自己研究一下C++中的hash_map。 参考：https://blog.csdn.net/u010025211/article/details/46653519?utm_medium=distribute.pc_relevant_bbs_down.none-task
C++简单实现HashMap
xin_hen的博客
08-22 1860
实现说明 线程不安全； 2倍扩容，方便使用位运算计算桶位置；但存在极端情况下的弊端； 不支持将链表转为红黑树 源码 #pragma once #include<string> //Hash函数 int Hash(int key) { return key; } //线程不安全容器 //2倍扩容，方便计算 //不支持链表转为红黑树 class HashMap { class Node { public: const int key; int val; const int
C++：Hash_map(哈希映射)
杨杨子江的博客
05-06 2805
猎豹网校的图 ###目录###0 为什么需要hash_map1 数据结构：hash_map原理2 hash_map 使用2.1 一个简单实例2.2 hash_map 的hash函数2.3 hash_map 的比较函数2.4 hash_map 函数3 相关hash容器4 其他4.1 hash_map和map的区别在哪里？4.2 什么时候需要用hash_map，什么时候需要用map?4.3 如何...
简单实现C++ hashmap(包含iterator)
choudan8888的博客
08-13 978
原理：原理很简单就是数组和链表，数组是用来散列的，链表主要用来存储的，链表的长度超过8个就转为红黑树（没实现）。 直接上代码： #include<iostream> #include<string> #include<unordered_map> using namespace std; #define LOADFACTOR 0.75 #define EXPANDFACTOR 2 template<class Key, class Value>
C++中的Hashmap
Misty_Rain_的博客
02-16 2万+
C++中的Hashmap Hashmap 结构 HashMap是基于哈希表实现的，每一个元素是一个key-value对，其内部通过单链表解决冲突问题，容量不足（超过了阀值）时，同样会自动增长。 HashMap是非线程安全的，只是用于单线程环境下,但是Hash Table是线程安全的（https://www.cnblogs.com/williamjie/p/9099141.html） 哈希表(key，value) 是把key值通过一个固定的算法即哈希函数转换成一个整型数字，然后就将该数字对数组长度进行取余，取
实现C++经典hashmap
专注金融量化投资交易 策略开发
04-17 488
C++经典hash是指使用哈希表实现的一种数据结构，可以快速地存储、查找和删除数据。在C++中，可以使用STL中的unordered_map或者手写哈希表来实现。如果发生哈希冲突，就将新的节点插入到链表的末尾。在查找时，遍历链表查找对应的节点。在删除时，将链表中对应的节点删除即可。哈希冲突：当两个不同的关键字被映射到同一个哈希表索引位置时，就会发生哈希冲突。解决哈希冲突的方法有开放地址法、链表法、再哈希法等。哈希函数：将关键字映射到哈希表中的索引位置的函数。常见的哈希函数包括取模法、乘法哈希、MD5等。
C++实现hashmap
qq_27011361的博客
03-24 1801
由于hashmap不是c++ stl中标准实现，这样在跨平台使用时就可能会出现问题，于是想到自己实现一个hashmap hash算法使用开链法解决hash冲突，主要实现了添加，删除，查找几个方法 头文件如下hashmap.h #ifndef _HASHMAP_H_ #define _HASHMAP_H_ template<class Key, class Value> c...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不停感叹的老林_<C 语言编程核心突破>

不打赏的人, 看完也学不会.

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值