哈希表的初步认知

最新推荐文章于 2025-03-08 16:24:45 发布
最新推荐文章于 2025-03-08 16:24:45 发布
阅读量573 收藏 1
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Nessie_zhao/article/details/80467993
版权

首先我们来认识一下什么是哈希表？？

  • 哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。

  • 给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(Hash）表，函数f(key)为哈希(Hash) 函数。

  • 哈希表hashtable(key，value) 就是把Key通过一个固定的算法函数既所谓的哈希函数转换成一个整型数字，然后就将该数字对数组长度进行取余，取余结果就当作数组的下标，将value存储在以该数字为下标的数组空间里。（或者：把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数）。 而当使用哈希表进行查询的时候，就是再次使用哈希函数将key转换为对应的数组下标，并定位到该空间获取value，如此一来，就可以充分利用到数组的定位性能进行数据定位。
    这里写图片描述

用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度较快

  • 但是哈希表在建立时会发生冲突，对于一些无法避免的冲突有以下几种处理办法：
    1.开放定址法
    H(key) = (H(key) + d)MOD m（其中m为哈希表的表长，d为一个增量）
    当得出的哈希地址产生冲突时，选取以下3种方法中的一种获取d的值，然后继续计算，直到计算出的哈希地址不再冲突为止
    （1）线性探测法：d = 1,2,3,….m-1
    当遇到冲突时，从发生冲突位置起，每次+1，向右探测，直到有空闲的位置为止
    （2）二次探测法：d = 12,-12,22,-22……………….
    当遇到冲突时，从发生冲突的位置起，按照+12，-12，+22，…如此探测，直到有空闲的位置
    （3）伪随机数探测法：d =伪随机数
    当遇到冲突时，从发生冲突的位置起，每次加上一个随机数，直到探测到空闲的位置结束
    2.再哈希法
    当通过哈希函数求得的哈希地址同其他关键字产生冲突时，使用另一个哈希函数计算，直到冲突不再发生
    3.链地址法
    将所有产生冲突的关键字所对应的数据全部存储在同一个线性链表中
    4.建立一个公共溢出区
    建立两张表，一张为基本表，另一张为溢出表。基本表存储没有发生冲突的数据，当关键字由哈希函数生成的哈希地址产生冲突时，就将数据填入溢出表
  • 开散列法又叫链地址法
    开散列法：首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头节点存储在哈希表中
    这里写图片描述

下面是两种方法实现哈希表：
1.线性探测法实现
.h文件

#pragma once
#include<stdio.h>
#include<stddef.h>
//我们此处存放的hash表期望存储的数据是键值对这样的结构
#define HashMaxSize 1000

typedef enum
{
    Empty,//空状态
    Deleted,//被删除的状态
    Valid,//有效状态
}Stat;

typedef int KeyType;
typedef int ValType;

typedef size_t (*HashFunc)(KeyType key);

//这个结构体表示hash表中的一个元素
//这个元素中同时包含了键值对
typedef struct HashElem
{
    KeyType key;
    ValType value;
    Stat stat;
}HashElem;
//[0,size)这个区间就不能表示hash表中有效元素
typedef struct HashTable
{
    HashElem data[HashMaxSize];
    size_t size;
    HashFunc func;//这是一个函数指针
}HashTable;

（1）初始化哈希表

size_t HashFuncDefault(KeyType key)
{
    return key % HashMaxSize;
}
void HashInit(HashTable* ht,HashFunc hash_func)
{
    ht->size = 0;
    ht->func = hash_func;
    size_t i = 0;
    for(;i < HashMaxSize;++i)
    {
        ht->data[i].stat = Empty;
    }
    return;
}
void TestInit()
{
    TEST_HEADER;
    HashTable ht;
    HashInit(&ht,HashFuncDefault);
    printf("size expected 0,actual %lu\n",ht.size);
    printf("func expected %p,actual %p\n",HashFuncDefault,ht.func);
}

（2）销毁哈希表

void HashDestroy(HashTable* ht)
{
    ht->size = 0;
    ht->func = NULL;
    size_t i = 0;
    for(;i < HashMaxSize;++i)
    {
        ht->data[i].stat = Empty;
    }
    return;
}
void TestDestroy()
{
    TEST_HEADER;
    HashTable ht;
    HashInit(&ht,HashFuncDefault);
    HashDestroy(&ht);
    printf("size expected 0,actual %lu\n",ht.size);
    printf("func expected NULL,actual %p\n",ht.func);
}

（3）向哈希表中插入一个元素

void HashInsert(HashTable* ht,KeyType key,ValType value)
{
    if(ht == NULL)
    {
        //非法输入
        return;
    }
    //判定hash表是否能够继续插入元素（根据负载因子）
    //假设此处我们把负载因子定义成0.8
    if(ht->size >= 0.8 * HashMaxSize)
    {
        //发现当前的hash表已经达到负载因子的上限，插入失败
        return;
    }
    //根据key来计算offset
    size_t offset = ht->func(key);
    //从offset位置开始线性的向后查找，找到第一个状态为Empty的位置进行插入
    while(1)
    {
        if(ht->data[offset].stat != Valid)//找到一个合适的位置
        {
            ht->data[offset].key = key;
            ht->data[offset].value = value;
            ht->data[offset].stat = Valid;
            ++ht->size;
            return;
        }
        //遇到key值相同的插入失败
        else if(ht->data[offset].stat == Valid && ht->data[offset].key == key)
        {
            return;
        }
        else
        {
            ++offset;
            if(offset >= HashMaxSize)
            {
                offset = 0;
            }
        }
    }
    return;
}
void HashPrint(HashTable* ht,const char* msg)
{
    printf("[%s]\n",msg);
    size_t i = 0;
    for(;i < HashMaxSize;++i)
    {
        if(ht->data[i].stat == Empty)
        {
            continue;
        }
        printf("[%lu  %d : %d]\n",i,ht->data[i].key,ht->data[i].value);
    }
    return;
}
void TestInsert()
{
    TEST_HEADER;
    HashTable ht;
    HashInit(&ht,HashFuncDefault);
    HashInsert(&ht,1,1);
    HashInsert(&ht,1,10);
    HashInsert(&ht,2,2);
    HashInsert(&ht,1001,11);
    HashInsert(&ht,1002,12);
    HashPrint(&ht,"插入若干个元素");
}

（4）根据key值查找一个元素是否在哈希表中，如果存在返回value值

int HashFind(HashTable* ht,KeyType key,ValType* value)
{
    if(ht == NULL)
    {
        //非法输入
        return 0;
    }
    if(ht->size == 0)
    {
        //空的hash表
        return 0;
    }
    //根据key算出offset
    size_t offset = ht->func(key);
    //从offset开始往后进行查找，每次取到一个元素，和key进行比较
    while(1)
    {
        //如果找到key相同的元素，查找成功，并把value返回
        if(ht->data[offset].key == key && ht->data[offset].stat == Valid)
        {
            *value = ht->data[offset].value;
            return 1;
        }
        //如果是一个空位置，则查找失败
        else if(ht->data[offset].stat == Empty)
        {
            return 0;
        }
        //如果此时key不相等，就继续向后查找
        else
        {
            ++offset;
            offset = offset > HashMaxSize ? 0 : offset;
        }
    }
    return 0;
}
void TestFind()
{
    TEST_HEADER;
    HashTable ht;
    HashInit(&ht,HashFuncDefault);
    HashInsert(&ht,1,1);
    HashInsert(&ht,1,10);
    HashInsert(&ht,2,2);
    HashInsert(&ht,1001,11);
    HashInsert(&ht,1002,12);
    ValType value;
    int ret = HashFind(&ht,1002,&value);
    printf("ret expected 1,actual %d\n",ret);
    printf("value expected 12,actual %d\n",value);
}

（5）根据key值删除哈希表中的某个元素

void HashRemove(HashTable* ht,KeyType key)
{
    if(ht == NULL)
    {
        //非法输入
        return;
    }
    if(ht->size == 0)
    {
        //空的hash表
        return;
    }
    //根据key计算offset
    size_t offset = ht->func(key);
    //从offset开始判定当前元素的key和要删除的key是否相等
    while(1)
    {
        if(ht->data[offset].key == key && ht->data[offset].stat == Valid)
        {
            //如果相等的话就把它标记为Deleted
            ht->data[offset].stat = Deleted;
            --ht->size;
            return;
        }
        else if(ht->data[offset].stat == Empty)
        {
            //如果当前的状态为空，那就在hash表中没找到，删除失败
            return;
        }
        else
        {
            //线性探测查找下一个元素
            ++offset;
            offset = offset > HashMaxSize ? 0 : offset;
        }
    }
    return;
}
void TestRemove()
{
    TEST_HEADER;
    HashTable ht;
    HashInit(&ht,HashFuncDefault);
    HashInsert(&ht,1,1);
    HashInsert(&ht,1,10);
    HashInsert(&ht,2,2);
    HashInsert(&ht,1001,11);
    HashInsert(&ht,1002,12);
    ValType value;
    int ret = HashFind(&ht,1002,&value);
    printf("ret expected 1,actual %d\n",ret);
    printf("value expected 12,actual %d\n",value);

    HashRemove(&ht,1002);
    ret = HashFind(&ht,1002,&value);
    printf("ret expected 0,actual %d\n",ret);
}

2.链地址法实现哈希表（哈希桶）
.h文件

#pragma once
#include<stdio.h>
#include<stddef.h>

#define HashMaxSize 1000

typedef int KeyType;
typedef int ValType;

typedef size_t (*HashFunc)(KeyType key);

//此结构体相当于是一个链表的节点
typedef struct HashElem
{
    KeyType key;
    ValType value;
    struct HashElem* next;
}HashElem;

typedef struct HashTable
{
    //如果我们的hash桶上的链表是一个不带头节点的链表（保存指针）
    //类型就用HashElem*
    //如果我们的hash桶上的链表是一个带头节点的链表（保存节点）
    //类型就用HashElem
    HashElem* data[HashMaxSize];
    size_t size;
    HashFunc func;
}HashTable;

创建和销毁节点

HashElem* CreateElem(KeyType key,ValType value)
{
    HashElem* new_node = (HashElem*)malloc(sizeof(HashElem));
    new_node->key = key;
    new_node->value = value;
    new_node->next = NULL;
    return new_node;
}
void DestroyElem(HashElem* node)
{
    free(node);
    return;
}

（1）初始化哈希表

size_t HashFuncDefault(KeyType key)
{
    return key % HashMaxSize;
}
void HashInit(HashTable* ht,HashFunc hash_func)
{
    if(ht == NULL)
    {
        return;
    }
    ht->size = 0;
    ht->func = hash_func;
    size_t i = 0;
    for(;i < HashMaxSize ;++i)
    {
        ht->data[i] = NULL;
    }
    return;
}
void TestInit()
{
    TEST_HEADER;
    HashTable ht;
    HashInit(&ht,HashFuncDefault);
    printf("size expected 0,actual %lu\n",ht.size);
    printf("func expected %p,actual %p\n",HashFuncDefault,ht.func);
}

（2）销毁哈希表

void HashDestroy(HashTable* ht)
{
    if(ht == NULL)
    {
        //非法输入
        return;
    }
    ht->size = 0;
    ht->func = NULL;
    size_t i = 0;
    //遍历所有的链表然后进行释放
    for(;i < HashMaxSize;++i)
    {
        HashElem* cur = ht->data[i];
        while(cur != NULL)
        {
            HashElem* next = cur->next;
            DestroyElem(cur);
            cur = next;
        }
    }
    return;
}

（3）向哈希表中插入一个元素

HashElem* HashBucketFind(HashElem* head,KeyType to_find)
{
    HashElem* cur = head;
    for(;cur != NULL;cur = cur->next)
    {
        if(cur->key == to_find)
        {
            break;
        }
    }
    return cur == NULL ? NULL : cur;
}
void HashInsert(HashTable* ht,KeyType key,ValType value)
{
    if(ht == NULL)
    {
        return;
    }
    //根据key算出offset
    size_t offset = ht->func(key);
    //在offset对应的链表中查找看当前的key是否存在
    HashElem* ret = HashBucketFind(ht->data[offset],key);
    if(ret != NULL)
    {
        //如果返回值不为空，就说明已经存在当前key
        //如果存在就认为插入失败
        return;
    }
    //如果不存在就采用头插的办法
    HashElem* new_node = CreateElem(key,value);
    new_node->next = ht->data[offset];
    ht->data[offset] = new_node;
    ++ht->size;
    return;
}
void HashPrint(HashTable* ht,const char* msg)
{
    printf("[%s]\n",msg);
    size_t i = 0;
    for(;i < HashMaxSize ;++i)
    {
        if(ht->data[i] == NULL)
        {
            continue;
        }
        printf("i = %lu\n",i);
        HashElem* cur = ht->data[i];
        for(;cur != NULL;cur = cur->next)
        {
            printf("[%d : %d] ",cur->key,cur->value);
        }
        printf("\n");
    }
    return;
}
void TestInsert()
{
    TEST_HEADER;
    HashTable ht;
    HashInit(&ht,HashFuncDefault);
    HashInsert(&ht,1,1);
    HashInsert(&ht,1,10);
    HashInsert(&ht,2,2);
    HashInsert(&ht,1001,11);
    HashInsert(&ht,1002,12);
    HashPrint(&ht,"插入若干个元素");
}

（4）根据key值查找一个元素是否在哈希表中，如果存在返回value值

int HashFind(HashTable* ht,KeyType key,ValType* value)
{
    if(ht == NULL || value == NULL)
    {
        return 0;
    }
    //根据key算出offset
    size_t offset = ht->func(key);
    HashElem* ret = HashBucketFind(ht->data[offset],key);
    if(ret == NULL )
    {
        return 0;
    }
    *value = ret->value;
    return 1;
}
void TestFind()
{
    TEST_HEADER;
    HashTable ht;
    HashInit(&ht,HashFuncDefault);
    HashInsert(&ht,1,1);
    HashInsert(&ht,1,10);
    HashInsert(&ht,2,2);
    HashInsert(&ht,1001,11);
    HashInsert(&ht,1002,12);
    int ret = 0;
    ValType value;
    ret = HashFind(&ht,1002,&value);
    printf("ret expected 1 ,actual %d\n",ret);
    printf("value expected 12,actual %d\n",value);
}

（5）根据key值删除哈希表中的某个元素

int HashBucketFindEx(HashElem* head,KeyType to_find,HashElem** pre_node,HashElem** cur_node)
{
    HashElem* pre = NULL;
    HashElem* cur = head;
    for(;cur != NULL;pre = cur,cur = cur->next)
    {
        if(cur->key == to_find)
        {
            break;
        }
    }
    if(cur == NULL)
    {
        return 0;
    }
    *pre_node = pre;
    *cur_node = cur;
    return 1;
}
void HashRemove(HashTable* ht,KeyType key)
{
    if(ht == NULL)
    {
        return;
    }
    if(ht->size == 0)
    {
        return;
    }
    //根据key算出offset
    size_t offset = ht->func(key);
    //通过offset找到对应的链表
    //在链表中找到指定的元素，并进行删除
    HashElem* pre =NULL;
    HashElem* cur = NULL;
    int ret = HashBucketFindEx(ht->data[offset],key,&pre,&cur);
    if(ret == 0)
    {
        //没找到，删除失败
        return;
    }
    if(pre == NULL)
    {
        //要删除的元素是链表的头结点
        ht->data[offset] = cur->next;
    }
    else
    {
        //要删除的点不是链表的头结点
        pre->next = cur->next;
    }
    DestroyElem(cur);
    --ht->size;
    return;
}
void TestRemove()
{
    TEST_HEADER;
    HashTable ht;
    HashInit(&ht,HashFuncDefault);
    HashInsert(&ht,1,1);
    HashInsert(&ht,1,10);
    HashInsert(&ht,2,2);
    HashInsert(&ht,1001,11);
    HashInsert(&ht,1002,12);
    int ret = 0;
    ValType value;
    ret = HashFind(&ht,1002,&value);
    printf("ret expected 1 ,actual %d\n",ret);
    printf("value expected 12,actual %d\n",value);
    HashRemove(&ht,1002);
    ret = HashFind(&ht,1002,&value);
    printf("ret expected 0 ,actual %d\n",ret);
}
《英雄编程体验课》第 15 课 | C语言中的数学库
英雄哪里出来
07-05 5万+
C语言中的数学库
AI大模型：优化电商平台个性化推荐的多样性与相关性平衡
AI天才研究院
10-12 1088
《AI大模型：优化电商平台个性化推荐的多样性与相关性平衡》 关键词：AI大模型、电商平台、个性化推荐、多样性、相关性、优化策略 摘要： 本文旨在探讨如何利用AI大模型优化电商
哈希表初始化、输出哈希表、插入键值（线性探测再散列法处理冲突）
cjj2543107638的博客
11-01 616
本关任务：初始化哈希表满足下面要求。将关键字序列（7、8、30、11、18、9、14）散列存储到散列表中，散列函数为： H(key) = (key*3) MOD 7，处理冲突采用线性探测再散列法，要求装填（载）因子为0.7。初始化的哈希表中元素均为-1。
哈希表的理解
weixin_30415113的博客
04-15 190
哈希表是种数据结构，它可以提供快速的插入操作和查找操作。第一次接触哈希表时，它的优点多得让人难以置信。不论哈希表中有多少数据，插入和删除（有时包括侧除）只需要接近常量的时间即0(1）的时间级。实际上，这只需要几条机器指令。 　　对哈希表的使用者一一人来说，这是一瞬间的事。哈希表运算得非常快，在计算机程序中，如果需要在一秒种内查找上千条记录通常使用哈希表（例如拼写检查器)哈希表的速度明显...
哈希基础知识
最新发布
m0_74672734的博客
03-08 351
哈希是一种将任意长度的输入（如字符串、文件、数据）通过哈希函数转换为固定长度输出的过程，其输出通常称为哈希值获哈希码哈希表(Hash Table)是一种基于哈希函数实现的数据结构，用于高效存储和查找键值对。
数据结构---哈希表的认识
一条二哈
10-05 348
哈希 哈希概念 顺序搜索以及二叉树搜索树中，元素存储位置和元素各关键码之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的 多次比较。搜索的效率取决于搜索过程中元素的比较次数。 理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。 如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通 过...
哈希表的初步认识
wind1_rain的博客
06-26 322
哈希表 - 幕布 哈希表诞生的前提在线性表、树等数据结构中，记录在结构中的相对位置是随机的，和记录的关键字之间不存在确定的关系，因此， 在结构中查找记录时需要进行一系列和关键字的比较。此类的查找方法建立在"比较"的基础上。在顺序查找时，比较的结果为等于 与 不等于两种可能；在折半查找中、二叉排序树查找和B-树查找时，比较的结果为小于、等于、和大于三种可能；查找的效率依赖于查找过程中所进行的比较次数。定义：理想的情况，希望不经过任何比较，一次存取便能得到所查记录，那就必须在记录的存储位置和它...
哈希表简单认识
小陈的博客
07-01 267
哈希值是由十进制数构成的值，在Java中根据对象的物理地址和属性、方法等映射出来的一个值（模拟的逻辑地址，并不是一个实际的存储物理地址），也就是说两个对象物理地址相同哈希值一定相同，但是哈希值相同的两个对象物理地址并不一定相同。在Java中哈希值可以通过Object的hashCode的方法获取在java中所有的引用类型每个引用都有相应的哈希值包括数组作用：提升查询数据的速度哈希表数其实是一种数据结构，在java中哈希表就是一个存放着哈希值通过哈希函数映射出来一个个值的数组。只是数组存放的是单一的数据，而哈希
算法本质的认知
# 1. 算法概述 ## 1.1 算法的定义和作用 算法是一系列解决问题的清晰指令步骤，它可以用来解决各种计算机科学和现实世界中的问题。一个好的算法能够有效地解决复杂的问题，并具有正确性、可读性、可靠性和高效性等...
知识图谱在智能问答系统中的应用
AI天才研究院
10-29 911
知识图谱在智能问答系统中的应用 关键词：知识图谱、智能问答系统、图数据库、数据采集、关系抽取、推理算法、问答系统架构 摘要：本文详细探讨了知识图谱在智能问答系统中的应用，从基础知识图谱的概念、表示方法，到构建流程，再到应用场景，进行了全面而深入的剖析。文章介绍了如何利用知识图谱实现智能问答系统，并讨论了相关算法和优化策
算法复杂度与宇宙信息密度的关系
AI天才研究院
01-21 2296
算法复杂度与宇宙信息密度的关系 关键词：算法复杂度、宇宙信息密度、时间复杂度、空间复杂度、信息论、计算理论 摘要：本文从算法复杂度的基本概念入手，探讨了算法复杂度与宇宙信息密度之间的关系。通过详细分析时间复杂度和空间复杂度，并结合宇宙信息密度的理论，探讨了两者在算法效率和宇宙信息处理中的应用，并提出了未来的研究方向。
哈希表：初始化、插入、删除、查找、查找
热门推荐
sophia__yu的博客
05-13 1万+
首先看一个面试题： 找到一个字符串中第一次出现一次的字符？ 思路是：如果是a-z26个字符，可以设置大小为26的数组，将每个字符出现的次数依次存放在数组里。如果是所有字符，将所有字符按照各自的ASSCII码作为下标将出现的次数存放在数组里。 代码如下： char FindFirstChar( const char *str) { int hashtable[256] = { 0...
Hash表的初步认识
qq_51194826的博客
03-30 532
简介 哈希表(hash table）也叫作散列表,作为数据结构的一种,它的优点在于无论是插入操作还是查找操作,它的时间复杂度是o(1),正是因为这个优点,在海量数据处理的场景都会有它的身影. 这其中的Hash也就是hash值,主要用于信息安全领域的加密算法,它把一些值转换为杂乱的128编码,这些编码值就叫做Hash值,换个方向去看这个Hash值,Hash就是一种数据与数据地址之间的映射关系. 对java源代码有一定的理解的同学，HashSet的底层代码原理是HashMap,而HashMap的底层原理就主要就
哈希表的创建、初始化、插入等
good18Levin的博客
10-17 2127
#include<iostream> #include<stdio.h> #include<stdbool.h> #include<stdlib.h> #include<vector> #include<map> #include<stack> #include<queue> #include<algorithm> using namespace std; //构造用开放地址探测法中的线性探测解决冲
对哈希表的一些理解
nydcc的博客
04-12 202
哈希表浅谈 哈希表通俗来说是将数据以某种规则计算来取到一个关键值key，然后查找时直接通过关键值key直接找到数据，这样平均情况下时间复杂度为O(1)。但是因为规则并不是万能的，所以会使得不同的数据得出的关键值一样，产生冲突。解决冲突的方法有两种，一个方法是为冲突关键字在哈希表中寻找另一个位置，称开放寻址法，一个方法是把在相同位置的所有关键字都存储在一个“挂”在那个位置上的数据结构中，称...
哈希表理解
weixin_44039506的博客
04-03 658
哈希表什么是哈希表？哈希表怎么存储数据的？哈希冲突处理哈希冲突哈希表的扩容哈希表怎么读取数据 什么是哈希表？ 百度百科： 散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 给定表M，存在函数f(key)，对任意给定...
对哈希表的理解
lihuadaiyu26的博客
05-07 322
哈希表（散列表）哈希函数：key与value地址的映射关系                value地址 = Hash(key)value地址对数组长度取余，可以得到连续的index其结构可如图所示：查找、插入、删除的时间复杂度为O(1)...
哈希表的简单理解
aosimth的博客
05-26 494
哈希表具有查询速度快，效率高的优点，是基于数组，特定情况下结合链表（红黑树）的数据结构。 设计思路： 设想用数组存储英文字母a-zzzzzzzz的字符串，这样的话总共有26^8种结果，而如果想要查询字母absdaw就只能通过遍历数组，非常影响速度。 灵感一闪而过，如果能把每个字母与数组下标绑定不就能快速查询，而每个字符都有一个唯一特定的ASCII值 思路1：提取字母的每个字符，转为ASCII值后相加 public int wordToNum(String word){ int tota
C语言实现哈希表功能详解
哈希表是一种高效的数据结构，它通过哈希函数来实现键（key）和值（value）之间的映射，从而可以快速进行数据的增删查操作。在C语言中，哈希表的实现并不直接依赖于语言的内建数据结构，而是需要程序员手动实现相关...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值