C++数据结构查找——哈希表（包含GIF和相关图示）

最新推荐文章于 2024-06-30 13:08:33 发布
最新推荐文章于 2024-06-30 13:08:33 发布
阅读量2.2k 收藏 12
点赞数 4
分类专栏： 数据结构 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56398315/article/details/126879083
版权

目录

一、介绍

哈希表(Hash Table)

1.定义

2.举例

3.本质

哈希冲突（Hash Collision)

1.定义

2.举例

二、哈希函数的构造

直接定址法

i.举例1

 ii.举例2

 iii.总结

数字分析法

i.举例

 ii.总结

除余法与平方法

其他方法

三、处理哈希冲突

链地址法：

开放寻址法：

四、STL库中的哈希表使用

五、哈希表的实现

1.链地址法

算法实现

 代码执行结果

 全部代码

2.开放寻址法

算法实现

全部代码

代码执行结果

六、总结

一、介绍

哈希表(Hash Table)

1.定义

"散列表"也叫哈希表，是一个 根据键值(Key)直接访问在内存中的存储位置 的数据结构。哈希表通过一个哈希函数(散列函数)，将键值(Key)映射为哈希表中的一个位置，我们可以通过这个位置来访问记录。

2.举例

为了方便理解，在另外一篇文章我看到一个很好的例子，以下加以阐述：

example：有一天你想给李四(键值Key)打电话，但是李四的电话你忘记了，这个时候你打开电话簿,电话薄里储存了人名首字母以及首字母对应的电话号码的页数的目录(哈希表)，这个目录是由你所确定的一个法则得来的：将人名的姓转换为英文再转换为单个首字母(如王二→Wang→W),这个法则就是哈希函数，通过目录你找到了李四所对应的首字母L,在首字母L的后面你找到了李四的电话所在的页数(位置),翻到该页你找到了李四的电话(记录)，然后你就可以给李四打电话了。

💡tips：为什么叫哈希表呢？因为散列表的英文就是Hash Table,谐音过来就是哈希表，为了方便起见，本文将直接称呼散列为哈希。

3.本质

哈希表的底层结构是数组，哈希表就是基于数组实现的一个数据结构，其意义在于可以根据一个键值Key就可以查找到一个数据在数组中的位置或者下标，从而加快查找的速度。我们可以知道，要想在一个数组里面查找我们想要的元素，我们可以利用顺序查找、折半查找、分块查找等方法（想知道这些方法的实现可以看我的另外一篇文章：查找算法：顺序查找、折半查找、分块查找

但是这些方法都远不及我们的这个哈希表，只需要一个键值就可以直接查找到该数据，因此查找速度十分之快。

哈希冲突（Hash Collision)

1.定义

在理想的情况下，每一个Key通过哈希函数的运算后得出来的值都是不一样的，但现实中，往往会出现两个不同的关键字经过同一个哈希函数的运算后得出来的值相同，这种情况就称之为哈希冲突。

2.举例

假如我们的电话簿有张三和张六这两个人，那么按照我们的哈希函数，也就是法则：取名字的姓的英文并转换为首字母，这个时候张三和张六这两个关键字经过哈希函数的处理之后都是Zhang,指向的都是存储了地址为0的一个数据域，这就造成了哈希冲突。

二、哈希函数的构造

tips:下面的图的数据都是虚构的，目的在于理解各个方法

哈希函数的构造方法有很多种，评价一个哈希函数的好坏我们可以通过不同关键字的冲突次数来评估，一个好的哈希函数产生哈希冲突的次数低，完全不产生哈希冲突的哈希函数也叫完美哈希函数，另外，一个好的哈希函数不会有过于复杂的计算，也就是说，如果你将关键字转换为对应地址的时间过长，那么我们查找数据的时候也会十分慢，因此一个好的哈希函数既要计算快，又要不冲突

直接定址法

这种方法适用于关键字简单且关键字连续的情况

i.举例1

如下图是一个国家不同年龄对应的不同人数的部分数据，我们要通过年龄来得到这个年龄的元素，我们观察年龄可以发现是从0-n岁的，恰好可以对应于一个连续的存储空间，因此我们可以直接把年龄作为地址，也就是:

Hashfunction(age)=age

address ( peoplenumber ) =Hashfunction ( age )

 ii.举例2

如下图是一个不同年份对应着的不同人口数量，关键字为不同年份，我们要通过不同年份来得到不同年份对应的人口数量，我们同样观察关键字，发现也是连续的，但并不是从0开始，难道我们用来存储记录的底层数组就只能从下标1979开始来存储记录吗，这显然是浪费内存与愚蠢的，我们这个时候就应该对哈希函数进行一个简单调整，即:

Hashfunction ( year ) = year - 1980

address ( peoplenumber ) = Hashfunction ( year )

 iii.总结

 直接定址法得到的哈希函数具有函数简单，地址分布均匀，且不会产生冲突的优点，但是需要预先知道关键字的分布情况，适合于查找表较小且关键字连续的情况,即:

Hashfunction ( key ) = A*key+B (A、B为常数)

数字分析法

当关键字中的一部分存在于其他的大部分关键字中，或者说大部分关键字都有着一个相同的部分，这个时候我们在对关键字调用哈希函数的时候我们就可以去掉这一部分，下面的例子就可以很好地说明数字分析法的作用

i.举例

观察下图，我们要通过电话来查找这个号码的号主，因此关键字就是电话，我们对关键字进行观察，我们可以发现所有的电话都是以135为前缀的移动的电话号码，因此我们就可以将这个前缀给他去掉再对其进行哈希函数的调用

 ii.总结

这种方法是适用于所有的哈希函数的构建的，因为在去除了相同的部分之后会对我们的hash更加有益，可以直接作为哈希函数的构建方法，也可以作为其中的一种调优方法

除余法与平方法

除余法是最为常见的一种构造方式，具体方法就是选取一个素数（只能被1和自身整除的数），并用关键字去取余，取余后得到的数就作为地址，即:

Hashfunction ( key ) = key % 素数

 同样，平方法就是对关键字进行平方操作后得到的数作为地址即：

Hashfunction ( key ) = key * key

其他方法

关于哈希函数的构造方法还有很多种方法，如折叠法、基数转换法等，具体的其他构造方法可以查看这篇文章：哈希函数的构造方法https://blog.csdn.net/Goodbye_/article/details/81407923?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522166358577616800192214687%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=166358577616800192214687&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-1-81407923-null-null.142%5Ev47%5Econtrol_1,201%5Ev3%5Econtrol_2&utm_term=%E5%93%88%E5%B8%8C%E5%87%BD%E6%95%B0%E7%9A%84%E6%9E%84%E9%80%A0&spm=1018.2226.3001.4187

三、处理哈希冲突

链地址法：

当一个关键字通过哈希函数之后产生的地址值和另外一个不同的关键字通过哈希函数产生的地址值相同时（即 Hashfunction ( key1 ) = Hashfunction ( key2 ) ),这个时候我们并不去寻找下一个地址，而是以当前得到的地址为头节点开辟一个链表空间，然后将发生哈希冲突的键值对存入这个链表中

gif举例

创造链表头数组，每个数组包含一个头节点，若发生哈希冲突则以链表头中的头节点延伸产生链表用来存储经过哈希函数运算之后地址相同的键值对（存储了key和value的一个数据结构），这么说可能有点难懂，通过下面的gif图我相信可以更好的帮助读者理解:

哈希函数采用的是取余法，即:

Address=Hasfunction(Key)

Hashfunction(Key)=Key%7

 

 i.我们对 7:seven 这个键值对进行存储，经过哈希函数之后得到的地址为0

ii.我们对0这个地址进行检查，发现里面没有存储键值对，我们就直接将该键值对存入下标为0的内存空间中

iii.我们对 14:fourteen 这个键值对进行存储，经过哈希函数之后得到的地址为0

iv.我们对 0 这个地址进行检查，发现里面已经存储了键值对了

v.那我们就以这个头节点创建一个链表，并在下一个节点对键值对 14:fourteen 进行存储

vi.同样的我们对 15:fifteen 这个键值对进行存储，最后存储到哈希表下标为1的位置

开放寻址法：

当一个键值对中的关键字通过哈希函数之后产生的地址值和另外一个不同的关键字通过哈希函数产生的地址值相同时（即 Hashfunction ( key1 ) = Hashfunction ( key2 ) ),这个时候key2对应的值还能放进Hashfunction ( key2 )中吗，显然不行，这样就会覆盖点key1所对应的值，因此这个时候我们就去查看Hashfunction ( key2 )的下一个地址，如果可用的话，就把key2的值存入这个新地址中

gif举例

以下图的gif为例我们可以对开放寻址法有更好的理解：

哈希函数采用的是取余法，即:

Address=Hasfunction(Key)

Hashfunction(Key)=Key%7

 i.我们对第一个键值对 7：seven 进行存储

ii.经过哈希函数之后我们找到了哈希表中的位置 0

iii.我们对这个位置进行检查，发现没有存储数据,那么我们就将该键值对进行存储

iv.我们对第二个键值对 14：fourteen 进行存储

v.经过哈希函数之后我们找到了哈希表中的位置 0

vi.我们对这个位置进行检查，发现已经存储了数据

vii.我们对当前地址的下一个地址进行检查，发现没有存储数据，那么我们就将该键值对进行存储，如果发现下一个地址也存了数据，那么就继续查看下一个地址直到发现没有存储数据的地址单元

四、STL库中的哈希表使用

在STL标准库中，哈希表是unordered_map,需要在头文件中#include<unordered_map>才能使用，下面我展示几个STL库中常用的哈希表的函数

#include<stdio.h>
#include<iostream>
#include<unordered_map>
using namespace std;


int main()
{
    //构造哈希表
    unordered_map<int,string> um;//哈希表定义unordered_map<type_key,type_value>,也就是说key是int类型的,value是string类型的

    //赋值操作
    um[0]="aa";//可通过操作符[]来规定key的对应value,um[key]="value"
    um[1]="bb";
    um[2]="cc";

    um.insert({3,"10"});//map.insert(pair<key_type,value_type>(key,value))
    um.insert({4,"29"});

    um.emplace(5,"hi");//map.emplace(key,value)
    um.emplace(6,"hi1");//emplace比insert效率高

    //迭代器操作
    //1.通过auto生成迭代器来打印各节点数据
    for (auto node:um)//通过auto编译器可以自动识别节点类型
    {
        cout<<node.first<<":"<<node.second<<endl;//节点第一个数据就是key，第二个数据就是key对应的值
    }
    //2.通过iterator
    for (unordered_map<int,string>::iterator it=um.begin(); it!=um.end(); it++)
    {
        int key=it->first;
        string value=it->second;
        cout<<"key为"<<key<<" value为"<<value<<endl;
    }
    

    //访问操作
    cout<<um[2]<<endl;//通过[key]访问key为2的value
    cout<<um.at(0)<<endl;//通过at(key)访问key为0的value

    //容量操作
    cout<< um.empty()<<endl;//查看是否为空
    cout<<um.size()<<endl;//得到哈希表容量
    
    //以key为参数查找哈希表中的value,若查找成功就返回该位置上的迭代器，否则返回um.end()
    unordered_map<int,string>::iterator iter;
    iter=um.find(2);
    cout<<iter->second<<endl;//第二个才是value

    //删除某个位置的元素或某个范围内的元素
    unordered_map<int, string>::iterator iter_begin = um.begin();
    unordered_map<int, string>::iterator iter_end =um.end();
    //um.erase(iter_begin);  //删除开始位置的元素
    um.erase(iter_begin, iter_end); //删除开始位置和结束位置之间的元素
    um.erase(5); //删除key为5的键值对

    //查找哈希表中元素所存在的桶编号
    int positon=um.bucket(5);//查找key5所在的桶的编号
    //得到桶的个数
    int bucketnum=um.bucket_count();
    //得到对应下标的桶内的元素数量
    int bucketsize=um.bucket_size(3);

    //清空哈希表
    um.clear();
    
    return 0;


}

想要看更加详细的STL库哈希表的时候建议看这篇文章，我个人觉得写的不错的：

STL哈希表的使用icon-default.png?t=M85Bhttps://blog.csdn.net/meraki/article/details/123452498?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522166428968516782390515923%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=166428968516782390515923&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~first_rank_ecpm_v1~rank_v31_ecpm-3-123452498-null-null.142^v50^new_blog_pos_by_title,201^v3^control_1&utm_term=c%2B%2B%20stl%E5%93%88%E5%B8%8C%E8%A1%A8&spm=1018.2226.3001.4187

五、哈希表的实现

1.链地址法

算法实现

对于链地址法我们使用节点作为存储结构，因此我们就需要定义节点类：

节点类:

class node
{
    public:
    int key;//关键值
    int value;//关键值所对应的值
    node* next;//指向当前节点的下一个节点的指针
};

 因为我们要对哈希表进行操作，因此我们也需要定义一个哈希表类，内部包含了一些成员以及方法：

哈希表类：

class Hashtable
{
    public:
    node* element;//定义一个链表头指针
    void init();//初始化函数
    int hashfunc(int key);//哈希函数
    void insert(int key,int value);//插入键值对
    int find(int key);//通过关键值得到关键值对应的数据
};

 初始化函数：

void Hashtable::init()
{
    element=new node[maxsize];//通过指针批量创建节点类的实例从而得到链表头数组
    for (int i = 0; i < maxsize; i++)//初始化链表头数组中的所有节点
    {
        element[i].key=empty;//初始化头结点的相关数据
        element[i].value=empty;
        element[i].next=NULL;
    }
    
}

哈希函数：

这里的哈希函数我们采用的是取余法，选择了7这个素数

int Hashtable::hashfunc(int key)
{
    return key%7;
}

插入函数：

void Hashtable::insert(int key,int value)
{
    if (element[hashfunc(key)].value==empty)//如果当前key值对应的头节点中未存储数据
    {
        element[hashfunc(key)].key=key;//那么就直接将该键值对存入
        element[hashfunc(key)].value=value;
    }
    else//如果当前key值对应的头结点中存储了数据说明发生了哈希冲突
    {
        node* ptr=element[hashfunc(key)].next;//定义一个指针指向头节点的下一个节点
        if (ptr==NULL)//如果该指针为空说明这个链表当前只有一个头节点
        {
            node* newnode=(node*)malloc(sizeof(node));//因此我们就创建一个新的节点用来存键值对
            element[hashfunc(key)].next=newnode;//将头节点与新节点相连
            element[hashfunc(key)].next->key=key;//对键值对进行存储
            element[hashfunc(key)].next->value=value;
            element[hashfunc(key)].next->next=NULL;
        }
        else//如果该链表含有多个节点
        {
        while (ptr->next!=NULL)//我们就将指针指到最后一个节点
        {
            ptr=ptr->next;
        }
        node* newnode=(node*)malloc(sizeof(node));//并创建一个新的节点
        ptr->next=newnode;//将最后一个节点与新节点相连
        ptr->next->key=key;//并将键值对进行存储
        ptr->next->value=value;
        ptr->next->next=NULL;
        }
    }
}

哈希查找函数:

int Hashtable::find(int key)
{
    node* ptr=element[hashfunc(key)].next;//生成一个指针指向当前头节点的下一个节点
    if (ptr==NULL)//通过指针检查链表是否只有一个头节点
    {
        if (key==element[hashfunc(key)].key)//直接对该头节点进行检查
        {
            return element[hashfunc(key)].value;//如果Key值相同就返回value
        }
        else
        {
            return ERROR;//否则返回查找失败
        }
        
    }
    else//链表不只有一个头节点
    {
    while (ptr!=NULL)//循环检查每个节点的Key值
    {
        if (ptr->key==key)
        {
            return ptr->value;//发现相同key值就返回value
        }
        else
        {
        ptr=ptr->next;//否则指针移动到下一个节点
        }
    }
        return ERROR;//如果链表遍历完毕都还未返回value说明查找失败
    } 
}

 主函数：

int main()
{
    Hashtable ht;
    ht.init();
    ht.insert(7,111);
    ht.insert(14,222);
    ht.insert(15,333);
    int tempkey;
    cin>>tempkey;
    cout<<"key:"<<tempkey<<" 对应的值为:"<<ht.find(tempkey)<<endl;
    return 0;
}

 代码执行结果

 全部代码

#include<stdio.h>
#include<iostream>
#define empty 0
#define maxsize 100
#define ERROR -1
using namespace std;

class node
{
    public:
    int key;//关键值
    int value;//关键值所对应的值
    node* next;//指向当前节点的下一个节点的指针
};

class Hashtable
{
    public:
    node* element;//定义一个链表头指针
    void init();//初始化函数
    int hashfunc(int key);//哈希函数
    void insert(int key,int value);//插入键值对
    int find(int key);//通过关键值得到关键值对应的数据
};

void Hashtable::init()
{
    element=new node[maxsize];//通过指针批量创建节点类的实例从而得到链表头数组
    for (int i = 0; i < maxsize; i++)//初始化链表头数组中的所有节点
    {
        element[i].key=empty;//初始化头结点的相关数据
        element[i].value=empty;
        element[i].next=NULL;
    }
    
}

int Hashtable::hashfunc(int key)
{
    return key%7;
}

void Hashtable::insert(int key,int value)
{
    if (element[hashfunc(key)].value==empty)//如果当前key值对应的头节点中未存储数据
    {
        element[hashfunc(key)].key=key;//那么就直接将该键值对存入
        element[hashfunc(key)].value=value;
    }
    else//如果当前key值对应的头结点中存储了数据说明发生了哈希冲突
    {
        node* ptr=element[hashfunc(key)].next;//定义一个指针指向头节点的下一个节点
        if (ptr==NULL)//如果该指针为空说明这个链表当前只有一个头节点
        {
            node* newnode=(node*)malloc(sizeof(node));//因此我们就创建一个新的节点用来存键值对
            element[hashfunc(key)].next=newnode;//将头节点与新节点相连
            element[hashfunc(key)].next->key=key;//对键值对进行存储
            element[hashfunc(key)].next->value=value;
            element[hashfunc(key)].next->next=NULL;
        }
        else//如果该链表含有多个节点
        {
        while (ptr->next!=NULL)//我们就将指针指到最后一个节点
        {
            ptr=ptr->next;
        }
        node* newnode=(node*)malloc(sizeof(node));//并创建一个新的节点
        ptr->next=newnode;//将最后一个节点与新节点相连
        ptr->next->key=key;//并将键值对进行存储
        ptr->next->value=value;
        ptr->next->next=NULL;
        }
    }
} 

int Hashtable::find(int key)
{
    node* ptr=element[hashfunc(key)].next;//生成一个指针指向当前头节点的下一个节点
    if (ptr==NULL)//通过指针检查链表是否只有一个头节点
    {
        if (key==element[hashfunc(key)].key)//直接对该头节点进行检查
        {
            return element[hashfunc(key)].value;//如果Key值相同就返回value
        }
        else
        {
            return ERROR;//否则返回查找失败
        }
        
    }
    else//链表不只有一个头节点
    {
    while (ptr!=NULL)//循环检查每个节点的Key值
    {
        if (ptr->key==key)
        {
            return ptr->value;//发现相同key值就返回value
        }
        else
        {
        ptr=ptr->next;//否则指针移动到下一个节点
        }
    }
        return ERROR;//如果链表遍历完毕都还未返回value说明查找失败
    } 
}


int main()
{
    Hashtable ht;
    ht.init();
    ht.insert(7,111);
    ht.insert(14,222);
    ht.insert(15,333);
    int tempkey;
    cin>>tempkey;
    cout<<"key:"<<tempkey<<" 对应的值为:"<<ht.find(tempkey)<<endl;
    return 0;
}

2.开放寻址法

在开放寻址法中我们使用数组作为键值对的存储结构，也可以用链表作为存储结构，在这里我使用了两个数组用来分别存储key和value

算法实现

哈希表类：

class Hashtable
{
    public:
    int v[maxsize];//用来存储value
    int k[maxsize];//用来存储key
    int hashfunc(int key);//哈希函数
    void initHashtable();//初始化函数
    void insert(int key,int value);//插入键值对
    int find(int key);//哈希查找
};

哈希函数：

int Hashtable::hashfunc(int key)
{
    return key%7; 
}

初始化哈希表：

void Hashtable::initHashtable()
{
    for (int i = 0; i < maxsize; i++)
    {
        v[i]=empty;//对两个数组进行初始化
        k[i]=empty;
    }
    
}

插入键值对：

void Hashtable::insert(int key,int value)
{
    int temp=key;
    int flag=0;//标志位
    while (v[hashfunc(temp)]!=empty)//当发现哈希冲突的时候
    {
        if (temp==key-1)//先看下面的注释再看这个注释:当到达原本的key值前面的一个地址时说明插入失败
        {
            flag=1;//标志位变化
            break;
        }
        temp+=1;//地址加一
        if (temp==maxsize+1)//如果地址已经到达了最大
        {
            temp=0;//从数组头开始检查
        }
          
    }   
    if (flag==0)//通过标志位来判断是否插入成功
    {
        v[hashfunc(temp)]=value;
        k[hashfunc(temp)]=key;
    }
    
    
}

哈希查找：

int Hashtable::find(int key)
{
    int flag=0;
    int temp=key;
    while (k[hashfunc(temp)]!=key)
    {
        if (temp==key-1)//先看下面的注释再看这个注释:当到达原本的key值前面的一个地址时说明查找失败
        {
            flag=1;//标志位变化
            break;
        }
        temp+=1;
        if (temp==maxsize+1)
        {
            temp=0;
        }  
    }
    if (flag==0)
    {
        return v[hashfunc(temp)];
    }
    else
    {
        return ERROR;//查找失败
    }
    
}

 主函数：

int main()
{
    Hashtable ht;
    ht.initHashtable();
    ht.insert(7,111);
    ht.insert(14,222);
    int key;
    cin>>key;
    cout<<"key:"<<key<<" 对应的值为:"<<ht.find(key)<<endl;
    return 0;
}

全部代码

#include<stdio.h>
#include<iostream>
#define maxsize 100
#define empty 0
#define ERROR -1
using namespace std;

class Hashtable
{
    public:
    int v[maxsize];//用来存储value
    int k[maxsize];//用来存储key
    int hashfunc(int key);//哈希函数
    void initHashtable();//初始化函数
    void insert(int key,int value);//插入键值对
    int find(int key);//哈希查找
};

int Hashtable::hashfunc(int key)
{
    return key%7; 
}

void Hashtable::initHashtable()
{
    for (int i = 0; i < maxsize; i++)
    {
        v[i]=empty;//对两个数组进行初始化
        k[i]=empty;
    }
    
}

void Hashtable::insert(int key,int value)
{
    int temp=key;
    int flag=0;//标志位
    while (v[hashfunc(temp)]!=empty)//当发现哈希冲突的时候
    {
        if (temp==key-1)//先看下面的注释再看这个注释:当到达原本的key值前面的一个地址时说明插入失败
        {
            flag=1;//标志位变化
            break;
        }
        temp+=1;//地址加一
        if (temp==maxsize+1)//如果地址已经到达了最大
        {
            temp=0;//从数组头开始检查
        }
          
    }   
    if (flag==0)//通过标志位来判断是否插入成功
    {
        v[hashfunc(temp)]=value;
        k[hashfunc(temp)]=key;
    }
    
    
}

int Hashtable::find(int key)
{
    int flag=0;
    int temp=key;
    while (k[hashfunc(temp)]!=key)
    {
        if (temp==key-1)//先看下面的注释再看这个注释:当到达原本的key值前面的一个地址时说明查找失败
        {
            flag=1;//标志位变化
            break;
        }
        temp+=1;
        if (temp==maxsize+1)
        {
            temp=0;
        }  
    }
    if (flag==0)
    {
        return v[hashfunc(temp)];
    }
    else
    {
        return ERROR;//查找失败
    }
    
}

int main()
{
    Hashtable ht;
    ht.initHashtable();
    ht.insert(7,111);
    ht.insert(14,222);
    int key;
    cin>>key;
    cout<<"key:"<<key<<" 对应的值为:"<<ht.find(key)<<endl;
    return 0;
}

代码执行结果

六、总结

👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍

哈希表是一个查找效率非常之高的数据结构，其中我们需要对其原理进行深刻的理解，包括哈希函数的构造、选用，以及哈希冲突的处理方式，另外我强烈建议读者自己试着去实现哈希表，这样子可以体会到其中原理，并且能够深入的理解如何处理哈希冲突，同时也可以巩固链表等相关知识，是百利而无一害的，而且实现起来也十分简单，如果喜欢本文的话麻烦点点赞哦！

👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍

臭刘皮
关注
  • 4
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
c++ 哈希表find_Leecode刷题---哈希表与字符串
weixin_39652646的博客
01-29 2746
哈希表，Hash table,也叫散列表，是根据关键字值（key）直接进行访问的数据结构，它通过把关键字值映射到表中一个位置（数组下标）来直接访问，以加快查找关键字值的速度，这个映射函数叫做哈希函数，存放记录的数组叫做哈希表给定表M，存在函数f，对任意的关键字值key，带入函数后若能得到包含该关键字的表中地址，称表M为哈希（Hash）表，函数（key）为哈希函数。预备知识1：最简单的哈希--字符...
哈希表查找
04-22
//待存入表格数据 char *key_input[] = { "auto", "break", "case", "char", "const", "continue", "default", "do", "double", "else", "enum", "extern", "float", "for", "goto", "if", "int", "long", "register", "return", "short", "signed", "sizeof", "static", "struct", "switch", "typedef", "union", "unsigned", "void", "volatile", "while" }; char *key_help_temp[] = { "auto function", "break function", "case function", "char function", "const function", "continue function", "default function", "do function", "double function", "else function", "enum function", "extern function", "float function", "for function", "goto function", "if function", "int function", "long function", "register function", "return function", "short function", "signed function", "sizeof function", "static function", "struct function", "switch function", "typedef function", "union function", "unsigned function", "void function", "volatile function", "while function" }; //功能：输入一个C语言关键字，快速提示这个关键字的功能及用法
哈希表查找（散列表查找） c++实现HashMap
hopegrace的博客
07-18 2592
算法思想： 哈希表 什么是哈希表 在前面讨论的各种结构(线性表、树等)中,记录在结构中的相对位置是随机的,和记录的关键字之间不存在确定的关系,因此,在结构中查找记录时需进行一系列和关键字的比较。这一类查找方法建立在“比较”的基础上。 在顺序查找时,比较的结果为“="与“!=”两种可能; 在折半查找、二叉排序树查找和B树查找时,比较的结果为“<"、"="和“>"3种可能。查找的...
【C++】哈希表
最新发布
m0_74808907的博客
06-30 1626
一文带你由浅入深掌握哈希表
C++ 哈希表
Han同学
02-26 2912
C++哈希表
C++ 哈希表查询_进入哈希函数结界的世界
y6123236的专栏
01-24 910
哈希表或称为散列表，是一种常见的、使用频率非常高的数据存储方案。哈希表属于抽象数据结构，需要开发者按哈希表数据结构的存储要求进行API定制，对于大部分高级语言而言，都会提供已经实现好的、可直接使用的API，如JAVA中有MAP集合、C++中的MAP容器，Python中的字典……使用者可以使用API中的方法完成对哈希表的增、删、改、查……一系列操作。如何学习哈希表？可以从2只需要知道哈希表是基于键值对存储解决方案，另需要熟悉不同计算机语言提供的基于哈希表数据结构的API实现，学会使用API。开发者的角度。
哈希表课程设计数据结构实验报告——哈希表设计
07-05
哈希表课程设计数据结构实验报告——哈希表设计 针对某个集体中的人名设计一个哈希表，使得平均查找长度不超过R，完成相应的建立和查表程序. 1.2 人名为汉语拼音形式，最长不超过18个字符(如：庄双双 ...
数据结构C++实验报告拉链法哈希表查找算法合工大
01-23
合工大数据结构C++实验报告拉链法哈希表查找算法
数据结构C++语言运用哈希表判断程序代码的相似性
06-22
对于两个C++语言的源程序代码，用哈希表的... 本程序能够遍历输出根据关键字和标识符建立的哈希表以及利用这两个哈希表统计C++语言源程序关键字和标识符的使用情况，最后通过比较向量的相对距离得出源程序的相似性。
编程语言(C++/Python/C#/javascript)中的数据结构——哈希映射
01-21
哈希表是一种使用哈希函数组织数据，以支持快速插入和搜索的数据结构。 有两种不同类型的哈希表：哈希集合(理解为set)和哈希映射(理解为dictionary)。 哈希集合是集合数据结构的实现之一，用于存储非重复值。 哈希...
数据结构查找方法 哈希查找 折半查找 顺序查找
08-27
在计算机科学中，数据结构和查找算法是至关重要的部分，它们直接影响到程序的效率和性能。本主题将深入探讨三种常见的查找方法：哈希查找、折半查找（又称二分查找）以及顺序查找。 首先，我们来理解哈希查找。哈希...
C++ 哈希表 班级人名查找
11-13
针对本班的人名设计一个杂凑表，数据表的长度为50~80个记录；分析平均查找长度，完成相应的建表和查表程序，设计直观的界面显示杂凑表的内容。 基本要求： 人名用汉语拼音表示，例如“苏志勇”表示为“su zhiyong”。人名的长度不超过19个字符。字符的取码可直接利用C语言中的toascii函数。
C++——哈希表与哈希查找
Wannna的博客
11-28 2156
1、哈希表类的哈希函数采用除留余数法哈希函数； 2、解决哈希冲突的函数采用开放定址法中的线性探察法。 3、建立一个由10个数据元素组成的集合； #include"iostream" using namespace std; #define m 15 //m是表长 #define n 13 //n是选择的质因子 typedef int KeyType; //关键字key类型 typedef i...
c++ 哈希表find_5.2 5.3 5.4 5.5 哈希函数与分离链接法及开放定址法，再散列
weixin_29514913的博客
01-27 381
template<typename HashedObj>void HashTable<HashedObj>::makeEmpty() { for (auto& thislist : thelists) thislist.clear();}template<typename HashedObj>bool HashTable<HashedObj&gt...
『数据结构』哈希表
叄拾叄画生
08-05 6869
什么是哈希？哈希冲突。哈希函数。哈希冲突解决方法。闭散列（线性探测、二次探测）。开散列（哈希桶）、开散列模拟实现（C++和Java）。
C++哈希表
异样旧日的博客
06-22 2141
哈希结构，C++代码模拟实现
查找算法之六 哈希查找(C++版本)
xupeng1644的博客
12-02 2748
算法介绍： 哈希算法应该不算是算法，而算是一种数据结构的应用。 向将数据放入哈希表中，然后再进行查找。 成员函数介绍： NewHashTable(int destSize) 构造一个destSize大小的数组m_pData，同时将其元素值都设置为INT_MAX，表示该位置未被使用。 bool NeedRehash() 判断负载因子，如果负载因子为1，就需要进行ReHash。 void Insert...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

臭刘皮

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值