【C++从入门到踹门】第十八篇（上）：哈希表实现

已于 2022-06-03 18:29:27 修改
阅读量1k 收藏 11
点赞数 6
分类专栏： C++ 文章标签： 散列表 数据结构 c++
于 2022-06-03 16:09:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43041053/article/details/125113358
版权

目录


在这里插入图片描述

完整代码实现已上传至gitee，戳->哈希表实现

哈希概念

什么是哈希表

之前学过的数据结构，如线性表（数组，链表）和树状结构（红黑树，AVL树），这些结构中存储元素的关键码Key与其存储位置是没有对应联系的。于是，在查找数据时，我们只能不断地让索引值key与数据结构中的存储元素的关键码比较来查询。例如顺序表的比较结果有 =和 ≠两种可能，于是查找的时间复杂度为O(N)，在树中则有 >,=,<三种可能，查找的时间复杂度为O(logN)。

如果我们将元素关键码和其存储位置相关联，即确立关键码与位置的映射关系，因此在查找时只要输入我们想要得到的数据的关键码，就可以通过映射找到它所存储的位置，那么我们就可以在表中直接搜索到元素，即查找的时间复杂度为O(1)。

那么首先在插入元素时就要按照这种映射关系计算出该元素存储的位置进行存放。

搜索数据，则对与元素的关键码进行同样的映射关系运算，求得值即为存储位置。

该方法称为哈希（散列）法， 其中的映射关系称为哈希函数，构造出来的结构即为哈希表。

直观了解哈希

这里通过一个例子来直观了解哈希的使用方法：

在这里插入图片描述

我们建立一个含有26个int的数组frequency，数组下标（i）与小写英文字母（变量c，char）一一对应，于是映射关系就有：i=c-'a'，数组元素则存放字母出现的次数，可以得到：

在这里插入图片描述

字母a出现的次数存放在frequency[0],字母b出现的次数存放在frequency[1]，…，字母z出现的次数存放在frequency[25]。只要再遍历一次字符串，通过字符找到frequency下标（即元素存放位置）就可以找到这个字符出现的次数，只要找到第一个为1的元素，即找到第一个只出现一次的字符。

代码如下：

class Solution {
public:
    char firstUniqChar(string s) {

        int frequency[26]={0};
        for(const auto& c : s)
        {
            frequency[c-'a']++;
        }

        char ret=' ';
        for(const auto& c : s)
        {
            if(frequency[c-'a']==1)
            {
                ret= c;
                break;
            }
        }
        return ret;
    }
};

哈希冲突

对于两个数据元素的关键字 keyi和keyj（i!=j），有keyi != keyj，但哈希函数计算后 ： Hash(keyi)==Hash(keyj)

即不同关键字通过相同的哈希函数计算出相同的哈希地址，这种现象称为哈希冲突或哈希碰撞

哈希函数

一个理想的哈希函数

  • 哈希函数的定义域必须包括需要存储的元素的全部关键码，如果散列表允许有n个地址，其值域只能在0~n-1之间
  • 哈希函数计算出来的地址能够均匀分布在整个空间中
  • 哈希函数应该比较简单

直接定址法

取关键字的线性函数为散列地址：Hash(Key)=A*Key+B (A,B为常数,A!=0)

  • 优点：简单，可适用于元素Key值分布均匀的元素
  • 缺点：需要实现得知关键字的分布情况（如上述的字母表），如果关键字的分布范围很广，将需要一个很大的哈希表，浪费空间。

除留余数法

设哈希表中存在的地址数为n，取一个不大于n，但最接近或等于m的素数p作为除数，按照哈希函数：Hash(Key)=Key%p，将关键码转换为哈希地址。

在这里插入图片描述

这是最简单且常用的构造哈希函数的方法，他不仅可以直接对关键字取余，还能对关键字折叠，平方取中后再取余。

平方取中法（不常用）

取关键字平方后的中间几位作为散列地址，关键字1234，平方得1522756，那么可抽取中间三位227为哈希地址。

随机数法（不常用）：

选择一随机函数，取关键字作为随机函数的种子生成随机值作为散列地址，通常用于关键字长度不同的场合。

折叠法（不常用）：

将关键字分割成位数相同的几部分，最后一部分位数可以不同，然后取这几部分的叠加和（去除进位）作为散列地址

哈希冲突处理

在之前介绍的除留余数法中会有哈希冲突的可能，取模后的数组下标出现重复：

在这里插入图片描述

下面将介绍解决方案

闭散列 —— 开放定址法

当发生哈希冲突时，若哈希表此时还没有被装满，说明哈希表中还存在空位置，那么可以把key存放到冲突位置的“下一个”空位置中

寻找下一个空位置的常见方法有线性探测法和二次探测法

  1. 线性探测

当发现哈希冲突时，从发生冲突的位置开始，依次往后探测一个位置，直到找到空位置。

  • 插入

    • 通过哈希函数函数获取哈希表的位置

    • 哈希函数：Hi=(H0+i)%p (i=0,1,2,3,…)

      • H0：通过哈希函数对元素的关键码进行计算得到的位置。
      • Hi：冲突元素通过线性探测后得到的存放位置。
      • p：表的大小。

在这里插入图片描述

  • 查找与删除

    使用哈希函数确定待删除元素的起点位置，如果当前位置的元素不是待删除元素，那就线性探测往后找，如果遇到空位置，说明没有该元素，停止搜索。

    如果找到该元素，不能直接删除，否则会影响其他元素的搜索。这里可以对每个位置进行标记，EMPTY(空)，EXIST(存在)，DELETE(删除)。

    当搜索遇到EMPTY状态，说明不存在该元素，因为线性探测已结束。

    如果遇到DELETE，则需要继续往后找，如果到达EMPTY或者删除结点的起点说明没有该元素。

    如果找到删除元素，直接标记为DELETE（DELETE状态和EMPTY状态可插入元素）。

在这里插入图片描述

在这里插入图片描述

  • 哈希表扩容

哈希表中如果元素过多，会大大提升哈希冲突的概率，这里需要提到一个概念：负载因子α=填入表中的元素个数/哈希表长度。

对于开放定址法，负载因子是特别重要的参数，应严格限制在0.7或0.8以下，超过0.8，查表时的缓存不命中概率按照指数曲线上升，因此当负载因子过红线时，应扩容哈希表。

  • 线性探测的缺点：

如果数据的哈希值过于集中容易产生数据的堆积，线性探测的次数过多，不同关键码都占据了其他的空位置，使得寻找关键码也要比较多次（踩踏），导致搜索效率降低。

  1. 二次探测

线性探测的缺陷是产生冲突的数据堆积在了一起，这与其找下一个空位置的方法有关系，二次探测寻找下一个空位的方法则是：

  • 哈希函数：Hi=(H0+i^2)%p (i=0,1,2,3,…)

    • H0：通过哈希函数对元素的关键码进行计算得到的位置。
    • Hi：冲突元素通过线性探测后得到的存放位置。
    • p：表的大小。

如果哈希值较为集中，那么二次探测后的哈希表元素的分布会相对稀疏一些，不容易导致堆积。采用二次探测同样需要考虑负载因子。

哈希表开散列

开散列又称哈希桶或者拉链法，对key值计算地址，具有相同地址的关键码将归于同一子集合，每一个子集合称为一个哈希桶，各个桶中元素通过链表连接起来，各链表的头结点存储在哈希表中。

在这里插入图片描述

可以看出，开散列的每个哈希桶中放的都是发生哈希冲突的元素。

闭散列解决哈希冲突采用的是抢占的方式，自己的位置如果被占用就只能转而占用他人的位置。开散列将哈希冲突的元素通过链表连接，然后将链表的头结点存储在哈希表中。开散列的方式使结点不会影响与自己哈希地址不同的元素的增删查改的效率，因此其负载因子稍大些，可达到1。

当哈希桶也有缺陷，极端情况下，插入的元素全部产生冲突，最终都放到同一个哈希桶中，于是删查改的效率就退化成了O(N)。这种场景可以考虑将链表的数据结构改为红黑树结构：

在这里插入图片描述

在Java语法的HashMap中，如果哈希桶中的元素超过8个就会将链表结构转换为红黑树结构，当红黑树的结点小于等于6个以后，又会恢复为链表。

在理想情况下，链表长度符合泊松分布，各个长度的命中概率依次递减，当长度为 8 的时候，概率仅为 0.00000006。这是一个小于千万分之一的概率。

链表长度超过 8 就转为红黑树的设计，更多的是为了防止用户自己实现了不好的哈希算法时导致链表过长，从而导致查询效率低，而此时转为红黑树更多的是一种保底策略，用来保证极端情况下查询的效率。通常如果哈希函数正常的话，那么链表的长度也不会很长，那么红黑树也不会带来明显的查询时间上的优势，反而会增加空间负担。

那么哈希表的结点结构可以设计为：

template <class T>
struct HashData
{
    forward_list<T> _list;
    set<T> _rbtree;
};

哈希表闭散列实现

我们使用闭散列方式建立哈希表，以实现 unordered_map 为前提（存放的元素类型为pair<Key,Value>）。

Hash仿函数

首先我们要确保key值是可以转换为非负整型的（为了取余），遇到存储类型为pair<string,int>时,其中key类型为string，这需要使用仿函数来帮助我们将string转为整型值。如果key是自定义类型，就需要用户自己指定仿函数，如自定义结构体，其中若存在唯一值，那可做为Key，如身份证号，如果没有为唯一值，则考虑多项组合。

STL中的unordered_map参数中的Hash函数：

在这里插入图片描述

我们自己的适合内置类型的仿函数如下：

template <class K>
//遇到double，float，char类型通过强转后返回
struct Hash
{
    size_t operator()(const K& key)
    {
        return (size_t)key;
    }
};

//特化string版本，使用BKDRHash装换算法
template<>
struct Hash<string>
{
    const size_t operator()(const string& key)
    {
        size_t hash = 0;
        // 把字符串的所有字母加起来   hash = hash*131 + key[i]
        for (size_t i = 0; i < key.size(); ++i)
        {
            hash *= 131;
            hash += key[i];
        }
        return hash;
    }
};

字符串哈希函数的对比：

在这里插入图片描述

关于字符串装换整型的Hash函数的详情戳：各种字符串Hash函数

哈希表基本框架

之前在闭散列中介绍过，一个哈希表存储单元，除了存元素之外还需存储状态：EMPTY，DELETE，EXIST

  • 存储单元框架如下：
//状态
enum State
{
    EMPTY,
    EXIST,
    DELETE
};

//存储类型结构体
template <class K,class V>
struct HashData
{
    pair<K, V> _kv;
    State _state=EMPTY;
};
  • 哈希表基本框架

使用vector<>作为容器，

template <class K, class V,class HashFunc=Hash<K>>//HashFunc负责将key值（可能为string）转换为size_t，方便取余
class HashTable
{
public:

    HashData<K, V>* find(const K& key)
    {
        //...
    }

    bool insert(const pair<K,V>&  kv)
    {
        //...
    }

    bool erase(const K& key)
    {
        //...
    }

private:
    vector<HashData<K,V>> _table;//容器
    size_t _n=0;//实际存储的元素个数
};

查找函数——find

查找步骤如下：

  1. 如果哈希表的容量为0，查找失败。
  2. 通过哈希函数计算出对应的哈希地址；
  3. 以哈希地址作为起始地点，如果没有找到元素，则采用线性探测（或者二次探测）向后查找数据，如果找到状态为EMPTY的元素则查找失败，过程中如果key值匹配且状态为EXIST，则找到元素。
public:
    HashData<K,V>* find(const K& key)
    {
        if(_table.size()==0)
        {
            return nullptr;
        }

        HashFunc hf;//仿函数（Key转整型）实例化对象
        size_t start = hf(key)%_table.size();
        size_t index = start;
        int i = 1;
        while (_table[index]._state!=EMPTY)
        {
            if(_table[index]._kv.first==key
                && _table[index]._state==EXIST)
            {
                return &_table[index];//找到返回元素指针
            }
            index = start+i;//线性探测
            //index = start+i*i;//二次探测
            i++;
            index %= _table.size();
        }
        return nullptr;
    }

插入元素——insert

插入步骤如下：

  1. 判断容器内元素数量如果为0，先预设10个元素空间的大小；
  2. 如果负载因子大于0.7，考虑增容（增容后需要对元素存放位置进行重新计算和存放）
  3. 用哈希函数计算出要插入的元素的起始位置，然后找空位置（状态为EMPTY和DELETE）。然后进行插入，并把状态改为EXIST（这里不用担心没有空位置，因为元素数量超过容量七成时会自动扩容）
  4. 此过程中如果待插入的元素在哈希表中已存在，则返回false。
public:
    bool insert(const pair<K,V>& kv)
    {
        if (find(kv.first) != nullptr)//防止重复
        {
            return false;
        }

        //扩容逻辑
        //初始时是一个空表，则resize空间。
        if (_table.size() == 0)
        {
            _table.resize(10);
        }
        else if ( 10 * _n / _table.size() > 7)//或者负载因子超过0.7，则需要换一个更大的表
        {
            //法一 新建一个table，然后将元素转移
            //vector<HashData> newtable;
            //newtable.resize(2 * _table.size());
            //for (auto& e : _table)
            //{
            //	if (e._state == EXIST)//因为新表的容量更大，所以元素位置会变化
            //	{
            //		//重新按照线性探测或二次探测规则在新表中插入
            //	}
            //}

            //法二 新建一个HashTable类(推荐)
            HashTable<K, V,HashFunc> newHT;
            newHT._table.resize(2*_table.size());
            for (const auto& e : _table)
            {
                if (e._state == EXIST)
                {
                    newHT.insert(e._kv);//复用了该类的insert成员函数
                }
            }
            _table.swap(newHT._table);
        }

        //插入新值的逻辑
        HashFunc hf;//仿函数 将key转换为size_t
        size_t start = hf(kv.first)%_table.size();
        size_t index = start;
        size_t i = 1;
        while (_table[index]._state == EXIST)
        {
            index =start+ i;//线性探测
            //index=start+i*i;//二次探测
            index %= _table.size();
            ++i;
        }
        _table[index]._kv = kv;
        _table[index]._state = EXIST;
        _n++;

        return true;
    }

删除函数——erase

删除步骤如下：

  1. 先通过find查找是否存在该元素，若不存在则删除失败；
  2. 若存在，则将该位置的状态置为DELETE；
  3. 将元素数量减1；
public:
    bool erase(const K& key)
    {
        HashData<K, V>* del = find(key);
        if (del == nullptr)//没有该点
        {
            return false;
        }
        del->_state = DELETE;
        _n--;
        return true;
    }

哈希表开散列实现

基础结构

在开散列的哈希表中，哈希表的结点类型，除了存储一个数据外还需存储指向下一个结点的结点指针。

当然也需要将key转换成size_t 的仿函数，和闭散列一样

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

template<>
struct Hash<string>
{
    const size_t operator()(const string& key)
    {
        size_t hash=0;
        for (size_t i = 0; i < key.size(); ++i)
        {
            hash *= 131;
            hash += key[i];
        }
        return hash;
    }
};


template <class K,class V>
struct HashData
{
    //链表指针
    HashData<K, V>* _next;
    //链表结点数据
    pair<K, V> _kv;

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

哈希表使用vector作为容器，元素类型则为结点指针：

template <class K, class V,class HashFunc=Hash<K> >
class HashTable
{
    typedef HashData<K, V> Node;
public:

    Node* find(const K& key)
    {
       //....
    }

    bool insert(const pair<K,V>& kv)
    {
        //...
    }

    bool erase(const K& key)
    {
        //...
    }


private:
    vector<Node*> _table;//指针数组
    size_t _n=0;//实际存放的元素数量
};

查找元素 —— find

步骤：

  1. 哈希表元素数量为0，查找失败。
  2. 计算出哈希地址。
  3. 找到对应哈希桶，遍历查找。
public:
    Node* find(const K& key)
    {
        HashFunc hf;//key转size_t 仿函数实例化
        if (_table.size() == 0)//元素数量为0，无法查找
        {
            return nullptr;
        }
        //计算哈希地址
        size_t index = hf(key) % _table.size();
        Node* cur = _table[index];
        while (cur)//遍历哈希桶
        {
            //key值匹配，
            //注意哈希表的Key值一定是可以做相等比较的
            //如果不存在相等运算符，则提供重载
            if (cur->_kv.first == key)
            {
                return cur;
            }
            cur = cur->_next;
        }
        return nullptr;
    }

插入元素 —— insert

步骤：

  1. 查找哈希表中是否已存在待插入的元素，若存在则插入失败。

  2. 判断哈希表大小吗，若哈希表为0，则直接赋予空间；

  3. 若负载因子达到1，需扩容，

    这里的扩容方式与闭散列不同：闭散列是新建一个哈希表，再复用了成员函数insert的插入逻辑，而开散列的元素为结点指针，若new一个新结点后，还需对旧表结点delete，折损效率，不如新建一个指针数组，将旧表的元素插入至新数组中来得方便，不用进行结点的创建与释放。

  4. 计算哈希地址，将元素头插入对应哈希桶中；

  5. 有效元素数量+1。

public:
    bool insert(const pair<K,V>& kv)
    {
        //查找是否已有该元素
        if (find(kv.first))
        {
            return false;
        }
        HashFunc hf;//key转size_t仿函数实例化


        //空表或负载因子为1 增容
        if (_n == _table.size())
        {
            size_t newsize = _n == 0 ? 10 : 2 * _table.size();
            vector<Node*> newtable;
            newtable.resize(newsize);
            for (size_t i = 0; i < _n; ++i)
            {
                if (_table[i])//桶不空，遍历该哈希桶
                {
                    //拿到这个桶的头结点
                    Node* cur = _table[i];
                    while (cur)
                    {
                        Node* next = cur->_next;

                        //重新计算映射位置
                        size_t index = hf(cur->_kv.first) % newtable.size();
                        //插入至新表
                        cur->_next = newtable[index];
                        newtable[index] = cur;
                        cur = next;
                    }
                }
            }
            _table.swap(newtable);//交换哈希表
        }


        size_t index = hf(kv.first) % _table.size();
        Node* newnode = new Node(kv);

        //头插
        newnode->_next = _table[index];
        _table[index]= newnode;
        ++_n;

        return true;
    }

删除元素 —— erase

步骤：

  1. 计算哈希结点地址；
  2. 找到对应哈希桶；
  3. 遍历哈希桶；
  4. 将元素从单链表中移除，元素数量-1。
public:
    bool erase(const K& key)
    {
        HashFunc hf;//key转size_t仿函数实例化
        //1.计算哈希地址
        size_t index = hf(key) % _table.size();

        //2.在桶中寻找待删除结点
        Node* cur = _table[index];
        Node* prev = nullptr;
        while (cur)
        {
            if (cur->_kv.first == key)
            {
                if (prev == nullptr)//cur为头结点
                {
                    _table[index]= cur->_next;
                }
                else//cur为中间结点
                {
                    prev->_next = cur->_next;
                }
                delete cur;
                --_n;
                return true;
            }
            prev = cur;
            cur = cur->_next;
        }
        return false;
    }

如何设置哈希表的大小（拓展）

上文我们得知，在初次插入数据时需要给定数组的初始大小，以及当负载因子超过限定时需要扩容，而有研究表明当数组的长度为素数时，可以减少除留余数法的哈希冲突。

于是获取素数大小

public:
    GetNextPrime(size_t prime)
    {
        const int PRIMECOUNT=28;
        static const size_t primeList[PRIMECOUNT]=
        {
                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
        };
        size_t i=0;
        for(;i<PRIMECOUNT;++i)
        {
            if(primeList[i]>prime)
            {
                return primeList[i];
            }
        }
        return primeList[0];
    }

改造增容部分代码：

//改造前
//size_t newsize = _tables.size() == 0 ? 10 : 2 * _tables.size();
//改造后
size_t newsize = GetNextPrime(_tables.size());

— end —

青山不改 绿水长流

大桑树保安队
关注
专栏目录
AUTOSAR从入门到精通-【概念篇】基于 AUTOSAR 标准架构的智能远程防盗系统设计与实现
getusushu的博客
06-28 2013
车头，多对多的使用模式会带来更多安全性问题，包括：非授权驾驶员控制挂车、当前社会对于汽车的需求往往更偏向于功能的提升，因此汽车电子系统日渐复杂，以往，商用车驾驶员自行管理车头及挂车，但物流公司为了提高商用车驾驶员的。运输效率采用了车队管理模式，物流公司拥有数量庞大的挂车，驾驶员自行管理。提出了一个思想“软件定义汽车”，这一思想逐步改变了汽车电子软件的开发模。定义汽车”，我们更需要一种能将硬件和软件分离、功能主导开发的汽车电子软。同时随着科技的发展，人们对于汽车的需求已不仅仅局限于硬件上的升级，
点云从入门到精通技术详解100篇-基于点云位姿估计的运行管理系统设计与实现
getusushu的博客
10-18 336
我国聚变堆的建设水平大幅提升，同时为推进深空探索、高场核磁共振等研究提供一流水平的技术支持和功能完善的实验平台[2]。减轻人类工作负担的机器人慢慢出现在人类的视野中，发展至今体。在新时代下，人们对能源的需求越来越大，对机器人智能化的程度要求越来。越高，机器人在很多方面的感知已经远远超过了人类。达到的地方进行探索甚至是操作，就需要用到机器视觉来进行观察定位了。获取放在对其他国家的期望上，那中国将会在国际交流中处处受制于人，因此我。研究开发核聚变能，然而核聚变能源的开发是一个高投入、高风险、大规模、长。
C++实现哈希表。
TPON的博客
11-17 6638
C++模拟实现哈希表
Hash表（C++实现）
lovecontry
08-20 485
哈希表的几个概念： 映像：由哈希函数得到的哈希表是一个映像。 冲突：如果两个关键字的哈希函数值相等，这种现象称为冲突。 处理冲突的几个方法： 1、开放地址法：用开放地址处理冲突就是当冲突发生时，形成一个地址序列，沿着这个序列逐个深测，直到找到一个“空”的开放地址，将发生冲突的关键字值存放到该地址中去。 例如：hash(i)=(hash(key)+d(i)) MOD m (i=1,2,3,...
C++：哈希表
最新发布
Makise的博客
09-11 1289
一篇带你完全掌握哈希
C++ hash table 的编程实现
a130737的专栏
08-21 8823
关于Hash Table， 总结如下：
C++实现哈希表
Ly的博客
05-28 2947
本文主要是对哈希表这种数据结构进行介绍。含义是根据存储的值和存储的位置建立映射关系从而快速检索查找存储的数据，哈希表是一种非常高效的数据结构。本文会用C++介绍哈希表的相关实现。
哈希表(C++实现)
m0_50655389的博客
07-01 1735
可以不经过任何比较，一次直接从表中得到要搜索的元素
STL教程：C++ STL快速入门（非常详细）
digitalkee的博客
07-01 9153
网址　　http://c.biancheng.net/stl/ STL 是“Standard Template Library”的缩写，中文译为“标准模板库”。STL 是 C++ 标准库的一部分，不用单独安装。 C++ 对模板（Template）支持得很好，STL 就是借助模板把常用的数据结构及其算法都实现了一遍，并且做到了数据结构和算法的分离。例如，vector 的底层为顺序表（数组），list 的底层为双向链表，deque 的底层为循环队列，set 的底层为红黑树，hash_set 的底层为哈.
C++语言：C语言/C++语言的简介、发展历史、应用领域、编程语言环境IDE安装、最强学习路线之详细攻略
热门推荐
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
09-04 2万+
​ C++语言：C语言/C++语言的简介、发展历史、应用领域、编程语言环境IDE安装、最强学习路线之详细攻略 目录 C语言/C++语言的简介 C语言/C++语言的应用领域 C++语言的IDE安装 C++语言的学习路线 C++语言实现的算法案例集合 C语言/C++语言的简介 1995年之前，江湖比较平静，编程语言有C、basics、pascal、 fortran、汇编语言，还有foxbase（曾经被列入
从入门到精通：VC.net下游戏编程实战指南
同时，还介绍了数据结构如链表、哈希表和搜索算法，如快速排序和深度优先搜索，这些是游戏逻辑设计和性能优化的基础。 第九章和第十章进一步深入3D图形编程，讲解DirectX Graphics和3D场景的创建、渲染、变换以及...
一个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++ 实现哈希表的实例
08-29
主要介绍了C++ 实现哈希表的实例的相关资料,这里使用C++实现哈希表的实例帮助大家彻底理解哈希表的原理，需要的朋友可以参考下
C++哈希表实现
Code is to be happy
12-18 950
#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
C++哈希表的实现
Wzs040810的博客
12-23 5791
C++哈希表的实现
C/C++实现哈希表数据结构
技术成就梦想，梦想成就未来。If you try hard enough, it can be.
02-26 822
说明：哈希函数使用除留余数法。 使用 #include "tableinfo.h" #include "dicttable.h" #include <stdio.h> int main(int argc, char *argv[]) { DictTable dict_table; for(int i=0; i<100000; i++) { int table_no=i; char table_name[64];
【C++】哈希表模拟实现
m0_69442905的博客
10-10 1145
了解哈希表的几种实现方式，初步了解哈希函数，初步构建简单的封闭哈希表，实现插入，查找，删除等。然后对封闭哈希表基础上进行更新，引出介绍链式哈希表，实现最简单的插入查找，删除
C++ 哈希表实现
kkbca的博客
12-09 1138
什么叫做哈希表？相信大家在很多地方都听过哈希表这三个字。在之前，我看到java之父余胜军装小白面试的时候，对哈希表那是侃侃而谈，非常的羡慕他对哈希表的理解，在学习哈希表过后，我发现他的难度还不一定比得上红黑树，那让我们今天来揭开哈希表的神秘面纱。哈希表跟set和map结构类似，库函数如果是unordered_set，那就是Key模型库函数如果是unordered_map，那就是Key，Value模型。表我们很容易理解，那么什么是哈希？
C++通讯录系统设计：哈希表实现与性能比较
资源摘要信息:"数据结构课程设计：C++基于哈希表实现的通讯录系统源码+课程设计报告" 本课程设计资源提供了一个基于C++语言实现的通讯录系统，其中关键在于使用哈希表数据结构来提升电话号码查找的效率。哈希表以其...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值