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

最新推荐文章于 2024-05-06 03:09:53 发布
最新推荐文章于 2024-05-06 03:09:53 发布
阅读量1.4k 收藏 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);
*/

上面的程序的原题目为：

 

郑烯烃快去学习
关注
算法与数据结构【30天】集训营——概念术语介绍及基础知识准备（01）
迷茫与徘徊只会让你陷入绝境，欢迎私信博主，带你开始提升变现价值！
08-04 998
数据结构是一种具有一定逻辑关系，在计算机中应用某种存储结构，并且封装了相应操作的数据元素的集合。它包含三方面的内容，逻辑关系、存储关系以及操作。正确的算法的含义是：能够解决实际问题，输入的所有可能的合法的输入都能产生预期的正确的结果；能够在有穷的步骤内执行完程序；能够用最简短的语句最高效的完成任务。数据结构的前期知识，都是偏概念性的，需要我们有一定的了解这样才能对数据结构有一定的认识和体会。数据(data) 是对客观事物的符号表示。在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。...
c++ 哈希表find_leetcode哈希表hash-table总结（更新中）
weixin_31693157的博客
01-30 2636
目录：常用数据结构及其复杂度特点常用题型总结最近刷的是leetcode关于哈希表的tag，不过个人还是建议不找官方提供的tag刷，一下子200多道，全刷是受不了，可以直接去网上找汇总的题名，题的质量往往更高。可以参考下面几个汇总：leetCode. 哈希表专题(3)https://blog.csdn.net/sjt19910311/article/details/51336521LeetCode之...
ACWING 840. 模拟散列表 (哈希)
3000bookworm
08-09 357
维护一个集合，支持如下几种操作： 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
哈希表中的其本函数find和end
2301_81278039的博客
01-21 993
之所以要一起介绍这两个函数是因为当find函数没有找到对应值时会返回一个end函数。我们将数与其下标存到哈希表中，同时每次都检测有无该数对应的数。今天来介绍find函数和end函数。
C语言哈希查找算法
qq_54075859的博客
08-25 853
C语言哈希查找算法
查找算法之哈希查找
青萍之末的博客
06-11 7533
  哈希也称散列，哈希表是一种与数组、链表等不同的数据结构，与他们需要不断的遍历比较来查找的办法，哈希表设计了一个映射关系f(key)= address，根据key来计算存储地址address，这样可以1次查找，f既是存储数据过程中用来指引数据存储到什么位置的函数，也是将来查找这个位置的算法，叫做哈希算法。 1、相关名词 1. 桶：哈希表中存储数据的位置，每一个位置对应唯一的一个地址，桶就好...
【五月集训】Day07——哈希表
ChaunceyPeng的博客
05-07 767
哈希表 知识管理 五月集训
MySQL学习Day28——锁
m0_50460160的博客
03-07 909
所谓的锁其实是一个内存中的结构，在事务执行前本来是没有锁的，也就是说一开始是没有锁结构和记录进行关联的，当一个事务想对这条记录做改动时，首先会看看内存中是否有与这条记录关联的锁结构，没有就会在内存中生成一个锁结构与之关联。在普通的SELECT语句后边加FOR UPDATE，如果当前事务执行了该语句，那么它会为读取的记录加X锁，这样既不允许别的事务获取这些记录的S锁，也不允许获取这些记录的X锁，如果别的事务想要获取这些记录的S锁或者X锁，那么它们会阻塞直到当前事务提交之后将这些记录上的X锁释放掉。
Leap Day1——数据结构与算法 抽象数据类型、算法分析和效率(1)
最新发布
2401_84150154的博客
05-06 946
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点！
小王Java学习打卡day13——泛型，hashMap，LinkedHashMap，TreeMap
w1099938370的博客
05-20 330
泛型 ​ 为什么使用泛型 存在一些问题： 取集合元素的时候，取出来的是Object类型，需要使用的时候只能强转 添加元素的时候，缺乏规范，导致类型转换异常 设计原则：不要写重复的代码 泛型： 一种数据的约束 jdk 1.5之后出来的，提供编译时期的安全检查机制，给我们提供了自动的强制类型转换，安全 如何使用泛型？ 常见字母 T ——type K V —— key value E —— Element 使用 使用在类上 //一个类使用一个泛型 public c
哈希表查找(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语言实现
哈希表基础
yyuhuaaa的博客
03-18 497
哈希表是一种映射，存放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 489
散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。...
C语言：Hash表查找字符串内容
Nemoxy的博客
11-08 2854
#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 227
hash_map 基本原理是： 使用一个下标范围比较大的数组来存储元素。可以设计一个函数（哈希函数，也叫做散列函数），使得每个元素的关键字都与一个函数值（即数组下标，hash值）相对应，于是用这个数组单元来存储这个元素；也可以简单的理解为，按照关键字为每一个元素“分类”，然后将这个元素存储在相应“类”所对应的地方，称为桶。 但是，不能够保证每个元素的关键字与函数值是一一对应的，因此极有可能出现对于不同的元素，却计算出了相同的函数值，这样就产生了“冲突”，换句话说，就是把不同的元素分在了相同的“类”之中。 总
数据结构与算法——哈希表(学习笔记）
weixin_44076873的博客
04-01 197
一. 哈希表的基本介绍 散列表(Hash table, 也叫哈希表)，是根据关键码值(Key value)而直接进行访问的数据结构，也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度，这个映射函数叫做散列函数，存放记录的数组叫做散列表。 二. Google公司的一个上机题 有一个公司，当有新的员工来报道时，要求将该员工的信息加入(id,性别，年龄，名字，住址)当输入该员工id时，要求查找到该员工的所有信息。 要求： 1.不使用数据库，速度越快越好=>哈希表 2.添
哈希表 | 哈希表基础
weifengomg的博客
12-13 1783
哈希表基础
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

郑烯烃快去学习

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

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

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

打赏作者

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

抵扣说明：

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

余额充值