【c++/数据结构】哈希表

最新推荐文章于 2024-02-26 08:37:50 发布
最新推荐文章于 2024-02-26 08:37:50 发布
阅读量2.4k 收藏 5
点赞数
分类专栏： c/c++ 数据结构 c++/数据结构 文章标签： 哈希表 开散列方法 闭散列方法 哈希冲突 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LLZK_/article/details/53054214
版权
哈希表

哈希表（HashTable）又叫散列表，是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。
哈希表的做法其实很简单，就是把Key通过一个固定的算法函数既所谓的哈希函数转换成一个整型数字。把这个整型数字作为元素的下标存入数组（散列表），我们常用的算法有以下几种：

  1. 直接定址法
  2. 除留余数法
  3. 平方取中法
  4. 折叠法
  5. 数学分析法
  6. 随机数法

而这几种算法里面，最常用的还是前两种：
直接定址法——–>取关键字的某个线性函数为散列地址，Hash（Key）= Key 或Hash（Key）= A*Key + B，A、B为常数。
除留余数法——–>-取关键值被某个不大于散列表长m的数p除后的所得的余数为散列地址。Hash（Key）= Key%P。

不管是直接定址还是除留余数，这里肯定会存在一种情况——–>不同的key值经过处理后得到了相同的结果。我们称这种现象为哈希冲突（或者说哈希碰撞）。
当两个不同的元素经过哈希处理得到了相同的整型数据index，那么哪个元素该存入数组下标为index的位置上呢？另一个存放到哪呢？

哪里有压迫哪里就有斗争！哪里有冲突我们就要解决！

解决哈希冲突的办法：

闭散列方法（开放定址法）

它的核心思想就是把发生冲突的元素放到哈希表中的另一个位置。具体又可分为线性探测和二次探测。
假设我们现在有一个哈希表table[10]，大小为10。
将 89、18、49、58、9这5个key值插入table。（示例用除留余数法）
- 线性探测
线性探测要做的就是把发生冲突的元素插入从当前位置开始后移的第一个空位置。
我们用这几个key值分别模哈希表的大小10。得到每个应插入的下标。
89%10 = 9；
18%10 = 8；
49%10 = 9；
58%10 = 8；
9 % 10 = 9；
从上式可以看出89、49、9这三个元素发生冲突，18、8这两个发生冲突。
插入过程如图：
这里写图片描述

  • 二次探测
    二次探测的大致思想与线性探测相同，不同之处在于后移过程中它移动的大小为后移次数的平方。我们设后移的次数为i。
    仍为上述条件：
    这里写图片描述

    针对闭散列方法（开放定址法），载荷因子的概念就显得特别重要。

    散列表（哈希表）的载荷因子α =插入表中元素个数/散列表的长度。

    α是散列表装满程度的标志因子。由于表长的定值，α与“填入表中元素个数”成正比，α越大，表明填入表中的元素越多，产生冲突的可能性就越大；反之，α越小，表明填入表中的元素越少，产生冲突的可能性就越小。
    对于闭散列方法，载荷因子是特别重要的元素，应严格限制在0.7~0.8以下。没超过0.8，查表时的CPU缓存不命中按照指数曲线上升。因此，每当载荷因子超出范围，都应该resize散列表（扩容）。

开散列方法(拉链法或叫开链法)

实现原理就是将哈希表变成一个指针数组。每次发生冲突，九江发生冲突的元素链到当前位置下。
仍未上述条件，处理完结果如图：
这里写图片描述

闭散列方法（线性探测）
#include<iostream>
#include<vector>
using namespace std;

enum STATE
{
    EMPTY,
    EXSIT,
    DELETE
};


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


//特化
template<>
struct __Hashfunc<string>
{
public:
    size_t operator()(const string& k)
    {
        return BKDRHash(k.c_str());
    }
private:
    //字符串哈希处理算法
    static size_t BKDRHash(const char* str)
    {
        unsigned int seed = 131;// 31 131 1313 13131 131313
        unsigned int hash = 0;
        while (*str)
        {
            hash = hash*seed + (*str++);
        }
        return(hash & 0x7FFFFFFF);
    }
};


template<typename K, typename V>
struct HashNode
{
    K _key;
    V _value;

    STATE _sta;

    HashNode(const K& key = K(), const V& value = V())
        :_key(key)
        , _value(value)
        , _sta(EMPTY)
    {}
};

template<typename K, typename V, typename __HashFunc = __Hashfunc<K>>
class HashTable
{
    typedef HashNode<K, V> Node;
public:
    HashTable()
        :_size(0)
    {
        _table.resize(GetPrimenum(0));
    }
    bool Insert(const K& key, const V& value)
    {
        CheckSize();

        size_t index = Getindex(key);
        while (_table[index]._sta == EXSIT)
        {
            if (_table[index]._key == key)
            {

                _table[index]._value++;
                return false;
            }

            if (index == _table.size() - 1)
            {
                index = 0;
            }
            ++index;
        }
        _table[index]._key = key;
        _table[index]._value = value;
        _table[index]._sta = EXSIT;
        _size++;

        return true;


    }
    void Swap(HashTable<K, V>& hash)
    {
        this->_table.swap(hash._table);
        swap(_size, hash._size);
    }
    Node* Find(const K& key)
    {
        size_t index = Getindex(key);
        while (_table[index]._sta == EXSIT)
        {
            if (_table[index]._key == key)
            {
                return &_table[index];
            }
            if (index == _table.size() - 1)
            {
                index = 0;
            }
            ++index;
        }
        return NULL;
    }

    bool Remove(const K& key)
    {
        size_t index = Getindex(key);
        while (_table[index]._sta == EXSIT)
        {
            if (_table[index]._key == key)
            {
                _table[index]._sta = DELETE;
                _size--;
                return true;
            }
            if (index == _table.size() - 1)
            {
                index = 0;
            }
            ++index;
        }
        return false;
    }
protected:
    size_t Getindex(const K& key)
    {
        //return key%_table.size();
        __HashFunc h;
        return h(key) % _table.size();
    }
    size_t GetPrimenum(const size_t& sz)
    {
        const int Primesize = 28;
        static const unsigned long Primenum[Primesize] =
        {
            53ul, 97ul, 193ul, 389ul, 769ul,
            1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
            49157ul, 98317ul, 196613ul, 393241ul,
            786433ul,
            1572869ul, 3145739ul, 6291469ul, 12582917ul,
            25165843ul,
            50331653ul, 100663319ul, 201326611ul, 402653189ul,
            805306457ul,
            1610612741ul, 3221225473ul, 4294967291ul
        };
        for (int i = 0; i < Primesize; ++i)
        {
            if (Primenum[i] > sz)
            {
                return Primenum[i];
            }
        }
        return sz;
    }
    void CheckSize()
    {
        if (_table.size() == 0 || _size * 10 / _table.size() >= 8)
        {
            HashTable<K, V> NewHash;
            NewHash._table.resize(GetPrimenum(_table.size()));

            for (size_t i = 0; i < _table.size(); ++i)
            {
                NewHash.Insert(_table[i]._key, _table[i]._value);
            }
            this->Swap(NewHash);
        }

    }
protected:
    vector<Node> _table;
    size_t _size;
};
开散列方法（拉链法）
#include<iostream>
#include<vector>
using namespace std;
//特化
template<>
struct __Hashfunc<string>
{
public:
    size_t operator()(const string& k)
    {
        return BKDRHash(k.c_str());
    }
private:
    //字符串哈希处理算法
    static size_t BKDRHash(const char* str)
    {
        unsigned int seed = 131;// 31 131 1313 13131 131313
        unsigned int hash = 0;
        while (*str)
        {
            hash = hash*seed + (*str++);
        }
        return(hash & 0x7FFFFFFF);
    }
};


template<typename K, typename V>
struct HashNode
{
    K _key;
    V _value;

    HashNode<K, V>* _next;

    HashNode(const K& key, const V& value)
        :_key(key)
        , _value(value)
        , _next(NULL)
    {
    }
};

template<typename K, typename V, typename __HashFunc = __Hashfunc<K>>
class HashTable
{
    typedef HashNode<K, V> Node;
public:
    HashTable()
        :_size(0)
    {
        _tables.resize(GetPrimenum(0));
    }

    bool Insert(const K& key, const V& value)
    {
        CheckSize();

        size_t index = Getindex(key, _tables.size());

        Node* cur = _tables[index];
        Node* parent = NULL;

        if (_tables[index] == NULL)
        {
            _tables[index] = new Node(key, value);
            _size++;
            return true;
        }

        while (cur)
        {
            if (cur->_key == key)
            {
                cur->_value++;
                _size++;
                return true;
            }
            cur = cur->_next;
        }

        Node* newNode = new Node(key, value);
        newNode->_next = _tables[index];
        _tables[index] = newNode;
        _size++;
        return true;
    }
    Node* Find(const K& key)
    {
        size_t index = Getindex(key, _tables.size());

        if (_tables[index] == NULL)
            return NULL;
        Node* cur = _tables[index];

        while (cur)
        {
            if (cur->_key == key)
                return cur;
            cur = cur->_next;
        }
        return NULL;
    }

    bool Delete(const K& key)
    {
        size_t index = Getindex(key, _tables.size());

        if (_tables[index] == NULL)
        {
            return false;
        }

        Node* cur = _tables[index];
        Node* parent = NULL;

        if (cur->_key == key)
        {
            cur = cur->_next;
        }


        while (cur)
        {
            if (cur->_key == key)
            {
                if (cur->_next == NULL)
                {
                    parent->_next = NULL;
                }
                else
                {
                    parent->_next = cur->_next;
                }
                break;
            }
            parent = cur;
            cur = cur->_next;
        }

        if (cur)
        {
            delete cur;
            cur = NULL;
            return true;
        }

        return false;
    }
    void Print()
    {
        for (size_t i = 0; i < _tables.size(); ++i)
        {
            printf("tables[%d]->", i);
            Node* cur = _tables[i];
            while (cur)
            {
                cout << cur->_key << "->";
                cur = cur->_next;
            }
            cout << "NULL" << endl;
        }
    }
protected:
    void CheckSize()
    {
        if (_tables.size() == 0 || _size / _tables.size() >= 1)
        {
            vector<Node*> Newtable;
            Newtable.resize(GetPrimenum(_tables.size()));

            for (size_t i = 0; i < _tables.size(); ++i)
            {
                Node* cur = _tables[i];
                while (cur)
                {
                    Node* next = cur->_next;
                    _tables[i] = next;
                    size_t index = Getindex(cur->_key, Newtable.size());

                    Node* tmp = Newtable[index];
                    Newtable[index] = cur;
                    cur->_next = tmp;

                    cur = next;

                }
            }

            //this->_size = Newtable.size();
            this->_tables.swap(Newtable);

        }
    }
    size_t Getindex(const K& key, const size_t& size)
    {
        //return key%_table.size();
        __HashFunc h;
        return h(key) % size;
    }
    size_t GetPrimenum(const size_t& sz)
    {
        const int Primesize = 28;
        static const unsigned long Primenum[Primesize] =
        {
            53ul, 97ul, 193ul, 389ul, 769ul,
            1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
            49157ul, 98317ul, 196613ul, 393241ul,
            786433ul,
            1572869ul, 3145739ul, 6291469ul, 12582917ul,
            25165843ul,
            50331653ul, 100663319ul, 201326611ul, 402653189ul,
            805306457ul,
            1610612741ul, 3221225473ul, 4294967291ul
        };
        for (int i = 0; i < Primesize; ++i)
        {
            if (Primenum[i] > sz)
            {
                return Primenum[i];
            }
        }
        return sz;
    }
protected:
    vector<Node*> _tables;
    size_t _size;
};
LLZK_
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
DataTables:C ++的表格数据结构
04-17
数据表 C ++的数据表。 这些表的目标是包含其他数据框对象（例如R和Pandas DataFrame）的所有功能，同时保持计算和内存效率。 依存关系 CMAKE 安装 下载/克隆源代码并导航到源代码的根文件夹后，可以通过CMake安装项目，如下所示。 mkdir build cd build cmake .. Linux make && sudo make install 视窗 CMAKE应该创建一个Visual Studio项目文件以在VS中使用该项目。 该项目仅在Linux环境中进行了测试，而我在Windows中使用CMake的经验很少甚至没有。 用法 安装后，可以将DataTable结构导入其他C ++项目。 必须通过-l标志在g ++中链接项目，即g ++ <project> .cc -lDataTable 。 有时，链接通过CMake安装的项目时会出现错误。 谷歌
【C++从入门到踹门】第十八篇（上）：哈希表实现
qq_43041053的博客
06-03 783
哈希概念 什么是哈希表 直观了解哈希 哈希冲突 哈希函数 哈希冲突处理 闭散列 —— 开放定址法 哈希表开散列 哈希表闭散列实现 Hash仿函数 哈希表基本框架 查找函数——find 插入元素——insert 删除函数——erase 哈希表开散列实现 基础结构 查找元素 —— find 插入元素 —— insert 删除元素 —— erase 如何设置哈希表的大小（拓展）......
C++ 哈希表
最新发布
Han同学
02-26 1410
C++哈希表
对c++中的哈希表（map）分别根据key和value排序
weixin_44302602的博客
06-07 6981
因为刚刚接触c++不是很久 在用的时候有些困难 然后今天在刷题的时候 遇到一个需要对哈希表排序的操作 然后研究了很长时间在 这里和大家分享一下 可以根据不同的要求 对于key和value来排序 里边需要用到pair的知识 这个方法可以用偷梁换柱来形容 我们就用vector<pair<int,int>>来代替map<int,int> ...
C++之哈希表的使用
Huang_JinXin的博客
07-13 4万+
C++中的STL提供了hash_map来实现哈希表功能，在介绍hash_map的使用方法之前，我们先从哈希函数和哈希冲突来了解哈希表。 一、 哈希函数 所谓哈希函数就是从关键字（Key）到值（Value）的映射： Value=H(Key)Value=H(Key)Value=H(Key) 值反映了关键字的存储地址。 1、数字分析法 选取关键字中的几位数字作为值，一般选取数字分布比较均匀的几位。 H(...
C++实现哈希表
Ly的博客
05-28 2427
本文主要是对哈希表这种数据结构进行介绍。含义是根据存储的值和存储的位置建立映射关系从而快速检索查找存储的数据，哈希表是一种非常高效的数据结构。本文会用C++介绍哈希表的相关实现。
C++数据结构哈希表
04-01
数据结构课上的哈希表事例。适宜初学者使用和参考
数据结构C++实验报告拉链法哈希表查找算法合工大
01-23
合工大数据结构C++实验报告拉链法哈希表查找算法
哈希表 数据结构学校使用
07-11
假设人名为中国人姓名的汉语拼音形式。待填入哈希表的人名共有30个，取平均查找长度的上限为2。哈希函数用除留余数法构造，用线性探测再散列法或链地址法处理冲突。 [测试数据] 取读者周围较熟悉的30个人名
数据结构哈希表设计实验报告
07-08
大家程序还是要自己写啊 这次考试考了三十分程序设计，结构大多不会
数据结构哈希表
01-20
数据结构输出一个哈希表，这是我自己写的程序，输出完全没有问题，用C++编写，安全可靠。
【数据结构】c++实现HashTable（开链法）
wmy_1995的专栏
05-11 3240
#include #include using namespace std; template struct HashTableNode { K _key; V _value; HashTableNode* _next; HashTableNode(const K&key, const V&value) :_key(key) , _value(value) , _ne
【C++】哈希表
Edward_Asia的博客
02-23 731
(1)依次读取IP，i = BKDRHash(ip)%200(n)，i是多少ip就进入对应编号的小文件中，相同的ip就一定进入了同一个小文件，然后使用map统计一个小文件的ip的次数，就是这个ip准确的次数。注意：该函数中实际调用哈希桶的插入操作，用参数key与V()构造一个默认值往底层哈希桶中插入，如果key不在哈希桶中，插入成功，返回V()，插入失败，说明key已经在哈希桶中，将key对应的value返回。近似算法：将一个文件放入布隆过滤器，遍历另一个文件，看它在布隆过滤器中有没有，如果存在就是交集。
关于leetcode刷题详细介绍
热门推荐
智者之家
10-01 8万+
  虽然刷题一直饱受诟病，不过不可否认刷题确实能锻炼我们的编程能力，相信每个认真刷题的人都会有体会。现在提供在线编程评测的平台有很多，比较有名的有 hihocoder，LintCode，以及这里我们关注的 LeetCode。 LeetCode收录了许多互联网公司的算法题目，被称为刷题神器，我虽然早有耳闻，不过却一直没有上面玩过。   据了解，LeetCode 是一个非常棒的 OJ（Online J...
LeetCode算法题整理(200题左右)
qq_38253797的博客
10-18 1万+
Leetcode
Leetcode各种题型题目+思路+代码（共176道题及答案）
muli522的博客
05-16 4万+
文章目录 第一章：Leetcode 每日很多题 1、Leetcode-1047 删除字符串中的所有相邻重复项 2、剑指 Offer 53 - I. 在排序数组中查找数字 I 3、Leetcode704:二分查找 4、 Leetcode 227：基本计算器II 5、leetcode 224：基本计算器(带括号的计算) 6、Leetcode 15：三数之和：排序+双指针 7、剑指 offer 38.字符串的排列 8、Leetcode409：最长回文串 9、Leetcode 331：验证二叉树的前序序列化 10、
leetCode题型总结
逆流而上Mr李
08-25 2852
本文选取了LeetCode和剑指offer中的经典面试题，供大家进行参考 LeetCode leetcode 总计176道题，下面根据对应目录一一对应。 二分查找 位运算 分治算法 动态规划 双指针 哈希表 图 字符串 排序 搜索 数学 数组+矩阵 栈和队列 树 贪心算法 链表 一、二分查找 * [1. X的平方差](#1-求开方) * [2. ...
leetcode算法与代码总结
一只在cv道路上爬行的小乌龟~
07-13 2073
leetcode代码总结1.动态规划问题动态规划思想介绍1. 1.动态规划问题 动态规划思想介绍 1.
C++哈希表数据结构
10-05
C中的哈希表是一种使用哈希函数将键映射到存储位置的数据结构。它是一种高效的查找数据结构，可以在平均情况下实现常数时间的插入、删除和查找操作。 在C中，可以使用标准库中的哈希表实现，例如使用unordered_set或unordered_map来创建哈希表。unordered_set用于存储唯一的键，而unordered_map用于存储键值对。 下面是使用C++标准库中的unordered_map实现哈希表的示例代码： ``` #include <unordered_map> int main() { // 创建一个哈希表 std::unordered_map<int, std::string> hashMap; // 向哈希表中插入元素 hashMap.insert({1, "apple"}); hashMap.insert({2, "banana"}); hashMap.insert({3, "orange"}); // 访问哈希表中的元素 std::string fruit = hashMap[1]; // 输出 "apple" // 修改哈希表中的元素 hashMap[2] = "grape"; // 遍历哈希表中的元素 for (const auto& pair : hashMap) { int key = pair.first; std::string value = pair.second; // 对每个键值对执行操作 } // 删除哈希表中的元素 hashMap.erase(3); return 0; } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值