算法学习Day1——C之哈希表

最新推荐文章于 2024-05-06 03:09:53 发布
最新推荐文章于 2024-05-06 03:09:53 发布
阅读量1.5k 收藏 10
点赞数 3
文章标签： 散列表 算法 哈希算法 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Alkaid2000/article/details/123266012
版权

  • 思想：使用哈希函数将键映射到存储桶。

想要插入一个新的键，哈希函数将决定该键该分配到哪个桶中，并将该键存储在相应的桶中。

想要搜索一个键的时候，哈希表使用哈希函数来查找相应的桶，并在特定的桶中进行搜索。

  • 设计哈希函数：取决于键值的范围和桶的数量。完美的哈希函数可以使键和桶之间的一对一映射。在大多数情况下，哈希函数并不完美，会产生哈希冲突。

  • 冲突解决：在同一个桶中存在了多个键。

  • 如何解决冲突？

    1. 链表：将相同的哈希值的元素都放入这一链表当中。

    2. 开放地址：在h处产生冲突，则要从h出发找到下一个不冲突的位置。不断地检测h+1、h+2、h+3...

    3. 再哈希：再使用另外一个哈希函数产生一个新的地址。

  • 什么地方适用哈希表？

    二分法；快速删除、添加、查找....

一、链地址法

设计哈希表的大小为base。开辟一个大小为base的数组，数组的每一个位置是一个链表。

 

为了尽可能避免冲突，应该将base取为一个质数。

在这里取base为769。

先声明一个链表：

struct List{
	int val;				//保存键值使用
	struct List *next;		//指向下一个
};

 声明一个哈希函数，作用是求得余数后将其放入对应的数组中:

const int base = 769;
int hash(int key)
{
	return key%base;
}

写出一些方便调用的子函数：

添加值到数组元素的函数：

//@explain: struct传进来前面定义的结构体，x为要添加的变量
void listPush(struct List *head,int x)
{
    //分配空间
    struct List* tmp = malloc(sizeof(struct List));
    //将读取进来的值，存放在这个结构体的变量中
    tmp -> val = x;
    //指向下一个值
    tmp -> next = head -> next;
    //保存头指针使用
    head -> next = tmp;
}

 删除链表中的值函数：

//@explain:struct要操作的结构体类型，x为要删除的变量
void listDelete(struct List*head,int x)
{
    //遍历数组中某一项的结构体
    for(struct List* it=head;it->next;it=it->next)
    {
        if(it->next->val==x)
        {
            //修改其指向的节点
            //保存当前指向的那个节点，为了下面的删除
            struct List*tmp = it->next;
            it->next = tmp->next;
            //释放其所在的内存，相当于删除元素
            free(tmp);
            break;
        }
    }
}

释放单个数组下标的空间：

void listFree(struct List*head)
{
	//当头头指向NULL时，说明已经释放完毕
	while(head->next)
	{
		struct List*tmp = head->next;
		head->next = tmp->next;
		free(tmp);
	}
}

检验键值是否在当前的数组元素中：

//@explain:struct 用来操作的结构体，x将要检验的值
bool listContains(struct List*head,int x)
{
    //遍历
	for(struct List*it = head;it->next;it = it->next)
	{
		if(it->next->val==x)
		{
			return true;
		}
	}
	return false;
}

以上的函数即可满足：添加、删除、检测，其实已经够哈希表的一些使用了。接下来构造结构体数组（相当于初始化哈希表）：

typedef struct{
	struct List*data;	//构造哈希结构体数组
}MyHashSet;

初始化：

  1. 为哈希表申请空间内存。

  2. 初始化数组，为数组申请base（数组长度）的空间。

  3. 将里面的val值初始化为0，指针next指向null值。

MyHashSet* myHashInit()
{
    //使用结构体，申请内存
	MyHashSet* ret = malloc(sizeof(MyHashSet));
    //为数组申请内存，array[base]
	ret -> data = malloc(sizeof(struct List)*base);
    //对数组中的所有元素进行初始化，指针的下一个元素需要为空指针
	for(int i=0;i<base;i++)
	{
		ret->data[i].val=0;
		ret->data[i].next=NULL;
	} 
	return ret;
}

 构造哈希添加元素函数：

void myHashSetAdd(MyHashSet* obj,int key)
{
	int keyvalue = hash(key);
    //检测该行中是否存在与之重复的数字，防止重复
	if(!listContains(&(obj->data[h]),key))
	{
		listPush(&(obj->data[h]),key);
	}
}

构造哈希删除函数：

void myHashSetRemove(MyHashSet* obj,int key)
{
	int h=hash(key);
	listDelete(&(obj->data[h]),key);
}

构造检测函数：

bool myHashContains(MyHashSet* obj,int key)
{
	int h=hash(key);
	return listContains(&(obj->data[h]),key);
}

构造释放整个哈希表的函数，为了防止一直在占用内存：

void myHashSetFree(MyHashSet* obj)
{
	for(int i=0;i<base;i++)
	{
		listFree(&(obj->data[i]));
	}
	free(obj->data);
}

  • 时间复杂度：O(n/b)。其中n为哈希表中的元素数量，b为链表数量。

  • 空间复杂度：O(n+b)

对于整个函数：

struct List{
	int val;				//保存键值使用
	struct List *next;		//指向下一个
};


typedef struct {
    struct List*data;	//构造哈希结构体数组
} MyHashSet;

const int base = 769;
int hash(int key)
{
	return key%base;
}

//@explain: struct传进来前面定义的结构体，x为要添加的变量
void listPush(struct List *head,int x)
{
    //分配空间
    struct List* tmp = malloc(sizeof(struct List));
    //将读取进来的值，存放在这个结构体的变量中
    tmp -> val = x;
    //指向下一个值
    tmp -> next = head -> next;
    //保存头指针使用
    head -> next = tmp;
}

//@explain:struct要操作的结构体类型，x为要删除的变量
void listDelete(struct List*head,int x)
{
    //遍历数组中某一项的结构体
    for(struct List* it=head;it->next;it=it->next)
    {
        if(it->next->val==x)
        {
            //修改其指向的节点
            //保存当前指向的那个节点，为了下面的删除
            struct List*tmp = it->next;
            it->next = tmp-> next;
            //释放其所在的内存，相当于删除元素
            free(tmp);
            break;
        }
    }
}

//@explain:struct 用来操作的结构体，x将要检验的值
bool listContains(struct List*head,int x)
{
    //遍历
	for(struct List*it = head;it->next;it = it->next)
	{
		if(it->next->val==x)
		{
			return true;
		}
	}
	return false;
}

void listFree(struct List*head)
{
	//当头头指向NULL时，说明已经释放完毕
	while(head->next)
	{
		struct List*tmp = head->next;
		head->next = tmp->next;
		free(tmp);
	}
}

MyHashSet* myHashSetCreate() {
    //使用结构体，申请内存
	MyHashSet* ret = malloc(sizeof(MyHashSet));
    //为数组申请内存，array[base]
	ret -> data = malloc(sizeof(struct List)*base);
    //对数组中的所有元素进行初始化，指针的下一个元素需要为空指针
	for(int i=0;i<base;i++)
	{
		ret->data[i].val=0;
		ret->data[i].next=NULL;
	} 
	return ret;
}

void myHashSetAdd(MyHashSet* obj, int key) {
    int keyvalue = hash(key);
    //检测该行中是否存在与之重复的数字，防止重复
	if(!listContains(&(obj->data[keyvalue]),key))
	{
		listPush(&(obj->data[keyvalue]),key);
	}
}

void myHashSetRemove(MyHashSet* obj, int key) {
    int h=hash(key);
	listDelete(&(obj->data[h]),key);
}

bool myHashSetContains(MyHashSet* obj, int key) {
    int h=hash(key);
	return listContains(&(obj->data[h]),key);
}

void myHashSetFree(MyHashSet* obj) {
    for(int i=0;i<base;i++)
	{
		listFree(&(obj->data[i]));
	}
	free(obj->data);
}

/**
 * Your MyHashSet struct will be instantiated and called as such:
 * MyHashSet* obj = myHashSetCreate();
 * myHashSetAdd(obj, key);
 
 * myHashSetRemove(obj, key);
 
 * bool param_3 = myHashSetContains(obj, key);
 
 * myHashSetFree(obj);
*/

二、开放地址

其实本质就是申请一个很大很大空间的数组，当存在这个值的时候，返回1，如果没有就返回-1。

这种方法时间复杂度较低，但是看见复杂度很高。而链地址方法则时间复杂度较高，而空间复杂度较低。

申请一个存放了1000001元素的数组：

#define SIZE 1000001
typedef struct{
	int val[SIZE];
}MyHashSet;

初始化：

MyHashSet* myHashSetCreate()
{
	MyHashSet *ret;
	//申请内存空间
	ret = (MyHashSet*)malloc(sizeof(MyHashSet));
	//将所有元素初始化为0
	memset(ret->val,0,sizeof(int)*SIZE);
	return ret;
}

当需要添加元素时，就在相应的元素值的坐标中，置一。

void myHashSetAdd(MyHashSet *obj,int key)
{
	obj->val[key]=1;
}

如果要移出该值，那就将其置为-1。检测其是否存在，那就检测该位的值是1还是-1就可以了。

以上建立的即为哈希集合。它有什么用？

  • 向哈希表中插入一个值key

  • 返回是否表中是否存在这个值？

  • 可以快速在数组中将该值删除，如果没有这个值那么什么都不做。

接下来看看哈希映射：

  • 为什么要使用哈希映射？

当我们需要更多的信息时，而不仅仅是键。然后通过哈希映射建立密钥与信息之间的映射关系。

  • 用在哪？

给定一个数组，要求返回两个数字的索引，让他们相加可以得到特定的目标值。

  

 对于这道题，可以使用暴力解法可以解决：

int* twoSum(int* nums, int numsSize, int target, int* returnSize){

        for(int i=0;i<numsSize;++i)
        {
            for(int j=i+1;j<numsSize;++j)
            {
                if(nums[i]+nums[j]==target)
                {
                    int *ret = malloc(sizeof(int)*2);
                    ret[0]=i;
                    ret[1]=j;
                    //要注意函数块定义域的问题
                    *returnSize = 2;
                    return ret;
                    
                }
            }
        }
        * returnSize = 0;
        return NULL;

}

这种方法方便快捷，但是时间复杂度过高。所以可以使用哈希表来解决这个问题，能够快速寻找数组是否存在目标元素，如果存在那么就找出索引，找到target-x的时间复杂度从O(N)降低到O(1)。

思想：对于每一个x，首先先查询哈希表中是否存在target-x，然后将x插入到哈希表中，即可保证不会让x和自己匹配。

  • 库<uthash.h>

关于这个库的知识可以在这篇博客中学到：开源库uthash第一弹uthash.h_小银子-CSDN博客_uthash.h

这个库所实现的hash表中可以提供类似于双向链表的操作，可以通过结构体hh.prev和hh.next当前节点的上一个节点或者下一个节点。

声明结构体hashTable：

struct hashTable{
	int key;	//键值
	int val;	//所在位置
	UT_hash_handle hh;
}

关于UT_hash_handle hh：

hh是内部使用hash处理句柄，在使用过程中，只需要在结构体中定义一个UT_hash_handle类型的变量即可，不需要为该句柄变量赋值，但必须在该结构体中定义该变量 。

UT_hash_handle源码：

struct UT_hash_handle {
   struct UT_hash_table *tbl;
   void *prev;                       /* prev element in app order      */
   void *next;                       /* next element in app order      */
   struct UT_hash_handle *hh_prev;   /* previous hh in bucket order    */
   struct UT_hash_handle *hh_next;   /* next hh in bucket order        */
   const void *key;                  /* ptr to enclosing struct's key  */
   unsigned keylen;                  /* enclosing struct's key len     */
   unsigned hashv;                   /* result of hash-fcn(key)        */
} UT_hash_handle;

 全局定义一个结构体数组：

struct hashTable* hashtable;

查找元素使用：HASH_FIND_INT():

//声明了一个返回值为hashTable类型指针的函数find，find函数的返回值为一个地址
struct hashTable* find(int key)
{
	struct hashTable* tmp;
	HASH_FIND_INT(hashtable,&key,tmp);
	return tmp;
}

  • HASH_FIND_INT用法：参数1：哈希表；参数2：要查找的键值的地址；参数3：哈希表结构的结构体指针。

  • 返回值：输入一个键值，哈希表则返回对应键的结构体，没有就返回NULL。

哈希表思路：

  • 数组第一个元素肯定不在哈希表中，所以将数组的第一个元素存入哈希表。

  • 第二个元素使用y=target-x，如果检测到y的值是否在map中，如果没有，则将此值加入到哈希表中，后面的元素也是一样的操作。

举例：数组[6 , 3 , 8 , 2 , 1]、target=8

 编写寻找函数：

int* twoSum(int* nums,int numSize,int target,int* returnSize)
{
	hashtable =NULL;
	for(int i=0;i<numsSize;i++)
	{
		struct hashTable* it = find(target-nums[i]);
		if(it != NULL)
		{
			int* ret = malloc(sizeof(int)*2);
            //返回当前找到的坐标，还有正在遍历的坐标就可以啦
			ret[0] = it->val,ret[1]=i;
			*returnSize = 2;
			return ret;
		}
		//如果没有那就插入
		insert(nums[i],i);
	}
	*returnSize = 0;
	return NULL;
}

 编写插入函数：

void insert(int ikey,int ival)
{
	struct hashTable* it=fine(ikey);
	if(it==NULL)
	{
		//申请空间，将数组再扩大
		struct hashTable* tmp = malloc(sizeof(struct hasTable));
		tmp->key=ikey;
		tmp->val=ival;
		HASH_ADD_INT(hashtable,key,tmp);
	}
	else
	{
		it->val = ival;
	}
}

  • 时间复杂度：O(N)，其中N是数组中的元素数量。对于每一个元素x，可以O(1)的寻址target-x。

  • 空间复杂度：O(N)，其中N是数组中的元素数量，主要为哈希表的开销。

代码：

struct hashTable {
    int key;
    int val;
    UT_hash_handle hh;
};

struct hashTable* hashtable;

struct hashTable* find(int ikey) {
    struct hashTable* tmp;
    HASH_FIND_INT(hashtable, &ikey, tmp);
    return tmp;
}

void insert(int ikey, int ival) {
    struct hashTable* it = find(ikey);
    if (it == NULL) {
        struct hashTable* tmp = malloc(sizeof(struct hashTable));
        tmp->key = ikey, tmp->val = ival;
        HASH_ADD_INT(hashtable, key, tmp);
    } else {
        it->val = ival;
    }
}

int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
    hashtable = NULL;
    for (int i = 0; i < numsSize; i++) {
        struct hashTable* it = find(target - nums[i]);
        if (it != NULL) {
            int* ret = malloc(sizeof(int) * 2);
            ret[0] = it->val, ret[1] = i;
            *returnSize = 2;
            return ret;
        }
        insert(nums[i], i);
    }
    *returnSize = 0;
    return NULL;
}

 好了，经历了这么多，该写一个哈希映射了，这是传统的哈希映射的写法，其实也跟前面的是差不多的，只不过多了几个功能：

//声明一节哈希表
struct List{
    int key;
    int val;
    struct List* next;
};

//结构体数组的声明
typedef struct{
    struct List* data;
}MyHashMap;

//添加元素到对应的下标
void listPush(struct List*head,int key,int val)
{
    //申请空间
    struct List* tmp = malloc(sizeof(struct List));
    tmp->key = key;
    tmp->val = val;
    tmp->next = head->next;
    head->next = tmp;
}

//删除对应下标元素
void listDelete(struct List*head,int key)
{
    for(struct List* it=head;it->next;it=it->next)
    {
        if(it->next->key==key)
        {
            struct List* tmp = it->next;
            it->next = tmp->next;
            free(tmp);
            break;
        }
    }
}

//查找元素子函数
struct List* listFind(struct List*head,int key)
{
    for(struct List*it = head;it->next;it=it->next)
    {
        if(it->next->key==key)
        return it->next;
    }
    return NULL;
}

//删除子函数
void listFree(struct List* head)
{
    while(head->next)
    {
        struct List*tmp = head->next;
        head->next = tmp->next;
        free(tmp);
    }
}

//规定数组大小
const int base = 769;

//规定哈希函数
int hash(int key)
{
    return key%base;
}

//哈希表的初始化
MyHashMap* myHashMapCreate() {
    MyHashMap* ret = malloc(sizeof(MyHashMap));
    ret -> data = malloc(sizeof(struct List)*base);
    for(int i=0;i<base;i++)
    {
        ret->data[i].key = 0;
        ret->data[i].val = 0;
        ret->data[i].next = NULL;
    }
    return ret;
}

void myHashMapPut(MyHashMap* obj, int key, int value) {
    int h = hash(key);
    //根据哈希函数分配内容
    struct List* rec = listFind(&(obj->data[h]), key);
    //创建链表
    if (rec == NULL) {
        listPush(&(obj->data[h]), key, value);
    } else {
        rec->val = value;
    }
}

int myHashMapGet(MyHashMap* obj, int key) {
    int h = hash(key);
    //得到下标后去查找
    struct List* rec = listFind(&(obj->data[h]), key);
    if (rec == NULL) {
        return -1;
    } else {
        return rec->val;
    }
}

void myHashMapRemove(MyHashMap* obj, int key) {
    int h = hash(key);
    //得到对应下标后删除
    listDelete(&(obj->data[h]), key);
}

void myHashMapFree(MyHashMap* obj) {
    //逐个释放
     for (int i = 0; i < base; i++) {
        listFree(&(obj->data[i]));
    }
    free(obj->data);
}

/**
 * Your MyHashMap struct will be instantiated and called as such:
 * MyHashMap* obj = myHashMapCreate();
 * myHashMapPut(obj, key, value);
 
 * int param_2 = myHashMapGet(obj, key);
 
 * myHashMapRemove(obj, key);
 
 * myHashMapFree(obj);
*/

上面的程序的原题目为：

 

郑烯烃快去学习
关注
c++ 哈希表find_leetcode哈希表hash-table总结（更新中）
weixin_31693157的博客
01-30 2636
目录：常用数据结构及其复杂度特点常用题型总结最近刷的是leetcode关于哈希表的tag，不过个人还是建议不找官方提供的tag刷，一下子200多道，全刷是受不了，可以直接去网上找汇总的题名，题的质量往往更高。可以参考下面几个汇总：leetCode. 哈希表专题(3)https://blog.csdn.net/sjt19910311/article/details/51336521LeetCode之...
C语言哈希查找算法
qq_54075859的博客
08-25 855
C语言哈希查找算法
ACWING 840. 模拟散列表 (哈希)
3000bookworm
08-09 361
维护一个集合，支持如下几种操作： I x，插入一个数 x； Q x，询问数 x 是否在集合中出现过； 现在要进行 N 次操作，对于每个询问操作输出对应的结果。 输入格式 第一行包含整数 N，表示操作数量。 接下来 N 行，每行包含一个操作指令，操作指令为 I x，Q x 中的一种。 输出格式 对于每个询问指令 Q x，输出一个询问结果，如果 x 在集合中出现过，则输出 Yes，否则输出 No。 每个结果占一行。 数据范围 1≤N≤105 −109≤x≤109 输入样例： 5 I 1 I 2 I 3 Q 2
哈希表 | 哈希表基础
weifengomg的博客
12-13 1789
哈希表基础
哈希表中的其本函数find和end
2301_81278039的博客
01-21 1011
之所以要一起介绍这两个函数是因为当find函数没有找到对应值时会返回一个end函数。我们将数与其下标存到哈希表中，同时每次都检测有无该数对应的数。今天来介绍find函数和end函数。
【五月集训】Day07——哈希表
ChaunceyPeng的博客
05-07 773
哈希表 知识管理 五月集训
MySQL学习Day28——锁
m0_50460160的博客
03-07 913
所谓的锁其实是一个内存中的结构，在事务执行前本来是没有锁的，也就是说一开始是没有锁结构和记录进行关联的，当一个事务想对这条记录做改动时，首先会看看内存中是否有与这条记录关联的锁结构，没有就会在内存中生成一个锁结构与之关联。在普通的SELECT语句后边加FOR UPDATE，如果当前事务执行了该语句，那么它会为读取的记录加X锁，这样既不允许别的事务获取这些记录的S锁，也不允许获取这些记录的X锁，如果别的事务想要获取这些记录的S锁或者X锁，那么它们会阻塞直到当前事务提交之后将这些记录上的X锁释放掉。
Leap Day1——数据结构与算法 抽象数据类型、算法分析和效率(1)
最新发布
2401_84150154的博客
05-06 954
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点！
小王Java学习打卡day13——泛型，hashMap，LinkedHashMap，TreeMap
w1099938370的博客
05-20 336
泛型 ​ 为什么使用泛型 存在一些问题： 取集合元素的时候，取出来的是Object类型，需要使用的时候只能强转 添加元素的时候，缺乏规范，导致类型转换异常 设计原则：不要写重复的代码 泛型： 一种数据的约束 jdk 1.5之后出来的，提供编译时期的安全检查机制，给我们提供了自动的强制类型转换，安全 如何使用泛型？ 常见字母 T ——type K V —— key value E —— Element 使用 使用在类上 //一个类使用一个泛型 public c
算法基础复盘笔记Day04【数据结构】—— KMP、字典树（Tire）、并查集、堆、哈希表
Java技术一点通
03-18 1892
并查集是一种树形的数据结构。并查集支持的两个操作：合并：将两个子集合并成一个集合。查找：确定某个元素在哪个集合。带路径压缩的查找：根节点是集合的代表，查找就是找到元素所在集合的根。1. 如果父节点等于自己，则找到了根并返回；2. 如果还没有找到根，则继续递归查找；3. 在返回的路上，顺带修改各节点的父节点为根。
哈希表查找(C语言实现)
03-24
NULL 博文链接：https://touch-2011.iteye.com/blog/1090305
哈希表操作（c语言版）
11-24
////采用除留余数法定义哈希表，哈希表长度为10，哈希函数为H(key)=key%13。产生冲突时采用线性探测法实现下面要求的功能。 ////（1）初始化哈希表,置空哈希表 ////（2）在哈希表中查找元素 ////（3）在哈希表中插入元素 ////（4）输出哈希表中所有元素 ////（5）建立Hash表
C语言实现的Hash哈希表
01-16
根据算法导论上的HashTable, C语言实现
查找算法之哈希查找
青萍之末的博客
06-11 7544
  哈希也称散列，哈希表是一种与数组、链表等不同的数据结构，与他们需要不断的遍历比较来查找的办法，哈希表设计了一个映射关系f(key)= address，根据key来计算存储地址address，这样可以1次查找，f既是存储数据过程中用来指引数据存储到什么位置的函数，也是将来查找这个位置的算法，叫做哈希算法。 1、相关名词 1. 桶：哈希表中存储数据的位置，每一个位置对应唯一的一个地址，桶就好...
哈希表基础
yyuhuaaa的博客
03-18 498
哈希表是一种映射，存放key和value。 1.力扣中的申明： unordered_map <int,int> m; //<>中的是key和value的数据类型 2.一般语法 map.find(要找的值) //找到，返回key；没找到，返回.end() map.end() //最后一个元素的后一位 相当于空值吧 map.count(key) // unoedered_map 不允许使用count计数， //如果有key，返回1；没有key，返回0 map
数据结构：哈希表
Fisher3652的博客
08-16 491
散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。...
C语言：Hash表查找字符串内容
Nemoxy的博客
11-08 2860
#include <stdio.h> #include <stdlib.h> #include <string.h> //拉链法 //链表节点，数据域存字符串 typedef struct Node{ char *str; struct Node *next; }Node; //顺序表（表头，大小） typedef struct HashTable{ //链表首地址,是链表头结点的顺序表，由于头结点是Node *,顺序表示Node ** Node **data
hash_map原理
weixin_45772795的博客
01-13 229
hash_map 基本原理是： 使用一个下标范围比较大的数组来存储元素。可以设计一个函数（哈希函数，也叫做散列函数），使得每个元素的关键字都与一个函数值（即数组下标，hash值）相对应，于是用这个数组单元来存储这个元素；也可以简单的理解为，按照关键字为每一个元素“分类”，然后将这个元素存储在相应“类”所对应的地方，称为桶。 但是，不能够保证每个元素的关键字与函数值是一一对应的，因此极有可能出现对于不同的元素，却计算出了相同的函数值，这样就产生了“冲突”，换句话说，就是把不同的元素分在了相同的“类”之中。 总
数据结构与算法——哈希表(学习笔记）
weixin_44076873的博客
04-01 198
一. 哈希表的基本介绍 散列表(Hash table, 也叫哈希表)，是根据关键码值(Key value)而直接进行访问的数据结构，也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度，这个映射函数叫做散列函数，存放记录的数组叫做散列表。 二. Google公司的一个上机题 有一个公司，当有新的员工来报道时，要求将该员工的信息加入(id,性别，年龄，名字，住址)当输入该员工id时，要求查找到该员工的所有信息。 要求： 1.不使用数据库，速度越快越好=>哈希表 2.添
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

郑烯烃快去学习

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

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

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

打赏作者

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

抵扣说明：

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

余额充值