数据结构---hash表

已于 2022-11-02 19:15:13 修改
阅读量1k 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 哈希算法 算法
于 2022-08-13 11:00:00 首次发布
本文链接：https://blog.csdn.net/m0_37844072/article/details/126277137
版权

目录

1.基本概念

2.hash冲突

3.hash的简单实现

4. hash表的应用场景

5.hash表和链表扩展的实现​​​​​​​

1.基本概念

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

2.hash冲突

比如

f(x) = x % 5;          //哈希函数

int hashTble[5];     //哈希表

int value[5];         //存放数据的数组

  1. 先忘value[0]存入 'A' [对应ascii码为65] ，  value[1]存入'F' [对应ascii码为70]
  2. f(65) = 0;  那么hashTable[0] = 0;
  3. f(70) = 0; 那么hashTable[1] = 0;

这就产生了冲突 （hanhTable的0和1是指向的一样的位置）

  • 解决方法：让存入hash表的值不一样

3.hash的简单实现

需要实现以下几个接口：

  • struct hash *hash_create(void);     //创建一个hash表

  • void hash_destroy(struct hash *ht);    //销毁hash表

  • int hash_insert(struct hash *ht, const char* key, void *data); //在hash表ht插入一个元素（key, data）

  • void *hash_lookup(struct hash *ht, const char* key);  //在hash表ht中，通过key得到value的指针

以下摘自linuxptp的hash实现

/**
 * @file hash.c
 * @brief Implements a simple hash table.
 * @note Copyright (C) 2015 Richard Cochran <richardcochran@gmail.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
#include <stdlib.h>
#include <string.h>

#include "hash.h"

#define HASH_TABLE_SIZE 200

struct node {
	char *key;
	void *data;
	struct node *next;
};

struct hash {
	struct node *table[HASH_TABLE_SIZE];
};

static unsigned int hash_function(const char* s)
{
	unsigned int i;

	for (i = 0; *s; s++) {
		i = 131 * i + *s;
	}
	return i % HASH_TABLE_SIZE;
}

//创建hash表
struct hash *hash_create(void)
{
	struct hash *ht = calloc(1, sizeof(*ht));
	return ht;
}

//清除hash表
void hash_destroy(struct hash *ht, void (*func)(void *))
{
	unsigned int i;
	struct node *n, *next, **table = ht->table;

	for (i = 0; i < HASH_TABLE_SIZE; i++) {
		for (n = table[i] ; n; n = next) {
			next = n->next;
			if (func) {
				func(n->data);
			}
			free(n->key);
			free(n);
		}
	}

	free(ht);
}

//向hash表插入元素
int hash_insert(struct hash *ht, const char* key, void *data)
{
	unsigned int h;
	struct node *n, **table = ht->table;
// 通过hash函数，得到key对应的value【value是hash表的位置下标】
	h = hash_function(key);
//避免得到的value值
	for (n = table[h] ; n; n = n->next) {
		if (!strcmp(n->key, key)) {
			/* reject duplicate keys */
			return -1;
		}
	}
//为插入的新元素（链表节点）分配内存
	n = calloc(1, sizeof(*n));
	if (!n) {
		return -1;
	}
//为链表节点赋值
	n->key = strdup(key);
	if (!n->key) {
		free(n);
		return -1;
	}
	n->data = data;
	n->next = table[h];
//将这个新元素的内存地址存入hash表
	table[h] = n;
	return 0;
}
//通过key在hash表ht中得到data
void *hash_lookup(struct hash *ht, const char* key)
{
	unsigned int h;
	struct node *n, **table = ht->table;

	h = hash_function(key);

	for (n = table[h] ; n; n = n->next) {
		if (!strcmp(n->key, key)) {
			return n->data;
		}
	}
	return NULL;
}

比较关键的逻辑就是:hash_insert函数，主要分为几步

  1. 通过hash_function()得到key对应的value，即在hashTable的位置
  2. 把传入的key,data存入一个node
  3. 把hashTable[value]赋值为node的内存地址

通过hash_lookup()找到key对应的data

  1. 先通过hash_function()算出value,即在hashTable的位置
  2. 通过hashTable[value]，找到key对应的那个node
  3. 通过node可找到key对应的data
  4. 返回data作为hash_lookup()的返回值
  • hash表的实现

uthash:  uthash简介_Fan Upward的博客-CSDN博客_uthash

4. hash表的应用场景

C语言实现的数据结构之------哈希表_smstong的博客-CSDN博客_c语言实现哈希表

  • 如果需要从链表中找到一个元素，那么就需要遍历链表。
  • 为了解决根据关键字快速找到元素的存放地址，哈希表应运而生。它通过某种算法（哈希函数）直接根据关键字计算出元素的存放地址。
  • 当不同的关键字可能产生出同样的hash值。解决方法可以是链式扩展：即把相同的hash值元素放到一个链表中。

5.hash表和链表扩展的实现

​​​​​​​

 

  • 代码实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


typedef struct Element
{
	int key;
	int value;  // 可以是任何结构的数据
} Element;

//数据存入单链表
typedef struct LinkTable
{
	Element data;
    struct LinkTable* next;
}Node;

typedef struct HashTable {
    Node* Head;
    int tablesize;
	int elementsize; 
} HashTable;


// 打印哈希表。
void PrintTable(HashTable *hh)
{
	int ii;
	printf("=========\n");

	for (ii = 0; ii < hh->tablesize; ii++)
	{
		Node *pp = hh->Head[ii].next;
		while (pp)
		{
			printf("[%d-%d] ", pp->data.key, pp->data.value);
			// printf("[%d-%s] ",pp->data.key,pp->data.value);
			pp = pp->next;
		}

		printf("\n");
	}

	printf("=========\n");
}

HashTable* InitHashTable(int size)
{
    HashTable* hh = (HashTable*)malloc(sizeof(HashTable));

    //分配单链表的头结点---size是几就有几个头链表
	hh->Head = malloc(sizeof(Node) * size);
	memset(hh->Head, sizeof(Node)* size, 0x00);

    hh->tablesize = size;
	hh->elementsize = 0;
}

unsigned int hash(HashTable *hh, int key)
{
	return key % hh->tablesize;  // 对表长取余。
}

Node* lookup(HashTable* hh, int key)
{
    // 根据key算出hashvalue
	int hashvalue = hash(hh, key);

	// 遍历单链表看是否有key
	Node* tmp = hh->Head[hashvalue].next;
    while (tmp != NULL) {
		if (tmp->data.key == key) 
		{
			printf("has key [%d]\n", key);
			return tmp; 
		}
		tmp = tmp->next;
	}
	return NULL;


}

void Insert(HashTable* hh, Element* lt)
{
    // find exist in hashtable?
    Node* result = lookup(hh, lt->key);
    if (result) {
		return;
	}
    // 根据key算出hashvalue
	int hashvalue = hash(hh, lt->key);
	printf("hashvalue = [%d]\n", hashvalue);

    // 更新链表结点的数据
	Node* nd = malloc(sizeof(Node));
	nd->data.key = lt->key;
	nd->data.value = lt->value;

    //根据hashvalue得到在链表的头结点数组的下标位置, 并插入nd结点
	nd->next = hh->Head[hashvalue].next;
    hh->Head[hashvalue].next = nd;

	hh->elementsize++;
}

void delete(HashTable* hh, int key)
{
    // find exist in hashtable?
    // Node* result = lookup(hh, key);
    // if (!result) {
	// 	printf("no this node\n");
	// 	return;
	// }

    // 根据key算出hashvalue
	int hashvalue = hash(hh, key);

	// 遍历单链表看是否有key
	Node* tmp = hh->Head[hashvalue].next;
	Node *last = tmp;
	Node *next = NULL;
    while (tmp != NULL) {
		if (tmp->data.key == key) 
		{
			printf("delete key [%d]\n", key);
			free(tmp);
			tmp = NULL;

			last->next = next;
			hh->elementsize--;
			break;
		}
        // update last and next node
		last = tmp;
		tmp = tmp->next;
		if (tmp) { next = tmp->next;}
	}


}

void freehashtable(HashTable *hh)
{
	if (hh == NULL)	return;
    
	//删除每个节点的链表
    for (int i = 0; i < hh->tablesize; i++)
	{
		printf("hash pos[%d]\n", i);
		Node* tmp = hh->Head[i].next;
		Node* tmp2;
		while (tmp != NULL) {
           printf("key %d val = %d\n", tmp->data.key, tmp->data.value);
		   tmp2 = tmp->next;
		   free(tmp);
		   tmp = tmp2;

		   hh->elementsize--;
		}
		PrintTable(hh);
		hh->Head[i].next = NULL;
	}
	printf("hash count[%d]\n", hh->elementsize);

}

int main()
{
	// 初始化哈希表。
	HashTable *hh = InitHashTable(10);


	Element ee;

	{
		ee.key = 10; ee.value = 110; Insert(hh, &ee);
		ee.key = 10; ee.value = 110; Insert(hh, &ee);
		printf("count=%d\n", hh->elementsize);
		PrintTable(hh);    // 打印哈希表 
	}

	{
		ee.key = 12; ee.value = 112; Insert(hh, &ee);
		PrintTable(hh);    // 打印哈希表 

		delete(hh, 12);     // 删除哈希表中关键字为12的数据元素。
		PrintTable(hh);    // 打印哈希表 
	}

	// 插入数据元素，关键字从10到20。
	ee.key = 10; ee.value = 110; Insert(hh, &ee);
	ee.key = 11; ee.value = 111; Insert(hh, &ee);
	ee.key = 13; ee.value = 113; Insert(hh, &ee);
	ee.key = 14; ee.value = 114; Insert(hh, &ee);
	ee.key = 15; ee.value = 115; Insert(hh, &ee);
	ee.key = 16; ee.value = 116; Insert(hh, &ee);
	ee.key = 17; ee.value = 117; Insert(hh, &ee);
	ee.key = 18; ee.value = 118; Insert(hh, &ee);
	ee.key = 19; ee.value = 119; Insert(hh, &ee);

	// // 插入数据元素，关键字从20到30。
	ee.key = 20; ee.value = 120; Insert(hh, &ee);
	ee.key = 21; ee.value = 121; Insert(hh, &ee);
	ee.key = 22; ee.value = 122; Insert(hh, &ee);
	ee.key = 23; ee.value = 123; Insert(hh, &ee);
	ee.key = 24; ee.value = 124; Insert(hh, &ee);
	ee.key = 25; ee.value = 125; Insert(hh, &ee);
	ee.key = 26; ee.value = 126; Insert(hh, &ee);
	ee.key = 27; ee.value = 127; Insert(hh, &ee);
	ee.key = 28; ee.value = 128; Insert(hh, &ee);
	ee.key = 29; ee.value = 129; Insert(hh, &ee);

	// // 插入数据元素，关键字从30到32。
	ee.key = 30; ee.value = 130; Insert(hh, &ee);
	ee.key = 31; ee.value = 131; Insert(hh, &ee);
	ee.key = 32; ee.value = 132; Insert(hh, &ee);


	// delete(hh, 12);     // 删除哈希表中关键字为12的数据元素。

	printf("count=%d\n", hh->elementsize);
	PrintTable(hh);    // 打印哈希表 

	// 在哈希表中查找关键字18。
	Node *pp = lookup(hh, 18);
	if (pp == 0) printf("LookUp(18) failed.\n");
	else printf("key=18,value=%d.\n", pp->data.value);

	freehashtable(hh);  // 销毁哈希表 

	return 0;
}

斯顿

L7256
关注
专栏目录
linux内核数据结构---hash表
shanzhizi的专栏
05-23 5624
关于linux内核链表请参考“linux内核数据结构---链表”。 链表虽然是最常见的数据结构，但实际使用中，由于链表的检索能力较差，更多的是作为队列和栈结构使用，如果需要查询，比如通过pid查找进程，通过描述符查找inode，就需要用到检索更快的数据结构——Hash表。 先来看Hash节点的定义： struct hlist_head { struct hlist_node *firs
Linux内核hash链表的理解与使用
to_be_better_wen的博客
11-12 2733
Linux内核 hash链表
数据结构---哈希（Hash）
MEANSWER的博客
06-19 4558
哈希1. 哈希概念2. 哈希函数3. 哈希冲突3.1 闭散列3.1.1 闭散列模拟实现3.2 开散列3.2.1 开散列模拟实现4. 基于开散列实现unordered_set5. 基于开散列实现unordered_map6. 闭散列和开散列对比7. 哈希的应用7.1 位图 对于set和map来说底层所使用的是红黑树，其在搜索上面已经很厉害了，为什么还需要在搞一个unordered_set和unordered_map呢？ #include<iostream> #include<vector&g
认识Hash表+Hash函数的设计+Hash冲突的处理+Hash表的实现+Java中的equals与hashCode
最新发布
Watermelon_Mr的博客
09-28 673
Hash表（1）如果a.equals(b)返回true，那么a和b的hashCode()必须要相等（2）如果a.equals(b)返回false，那么a和b的hashCode()有可能相等也有可能不相等（3）两个对象相等的必要条件是两个对象的hashCode()相等（4）使用hashCode和equals来共同判断两个对象是否相等。
Hash表
weixin_30662849的博客
09-28 202
　　　　　　　　　　　　　　　　　　　 　Hash表 　　Hash表也称散列表，也有直接译作哈希表，Hash表是一种特殊的数据结构，它同数组、链表以及二叉排序树等相比较有很明显的区别，它能够快速定位到想要查找的记录，而不是与表中存在的记录的关键字进行比较来进行查找。这个源于Hash表设计的特殊性，它采用了函数映射的思想将记录的存储位置与记录的关键字关联起来，从而能够很快速地进行查找。 1...
哈希表
傻子编程
03-19 884
概念 顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键 码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O( )，搜索的效率取决于搜索过程中 元素的比较次数。 除了情况4之外，其他情况可以直接删除 情况4不能直接删除，需要在其子树中找一个替代节点进行删除 */ // 请同学们根据上课掌握内容，完成删除的关键部分代码 return true; } } 101 102 103 104 105 106 107 理想的搜索方法：可以不经过任何比较
数据结构之hash表
tianshibaijia
12-28 141
1. 查找的数据是表式结构，可以想象成是数据库里的表； 2. 查找的目的是找出表中关键字与给定关键字相等的数据行； 3. 哈希表就是定义了每一个数据行的行号； 4. 哈希算法就是 行号=f(关键字)，所以在哈希表里查找数据时，不需要把给定关键字与每一行的关键字比较是否相等来找到行号，而是直接由给定的关键字计算出行号； 5.不同的关键字可能对应相同的行号，这就是冲突，最先占用此行号的数据就被...
数据结构hash表
huyunqiang111的博客
09-23 184
看一个实际需求，google公司的一个上机题: 有一个公司,当有新的员工来报道时,要求将该员工的信息加入(id,性别,年龄,住址..),当输入该员工的id时,要求查找到该员工的 所有信息. 要求: 不使用数据库,尽量节省内存,速度越快越好=>哈希表(散列) 哈希表的基本介绍 散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构...
Redis底层数据结构---hash表
chenmengyuanCSDN的博客
03-26 1215
Redis的哈希表—rehash详细讲解   Redis的性能优越，应用普遍，可以存储的键值个数大到上亿条记录，依然保持较高的效率。作为一个内存数据库，Redis内部采用了字典（哈希表）的数据结构实现了键值对的存储。随着数据量的不断增加，数据必然会产生hash碰撞，而Redis采用链地址法解决hash冲突。我们知道如果哈希表数据量达到了一个很大的量级，那么冲突的链的元素数量就会很大，这时查询效率就...
cpp代码-数据结构-hash
07-14
本篇将围绕"cpp代码-数据结构-hash"这一主题，深入探讨哈希表在C++中的实现及其重要性。 哈希表是一种数据结构，它通过一种称为哈希函数的映射关系，将数据的键（Key）转化为数组的索引，从而实现快速的插入、删除...
数据结构——哈希
m0_63020222的博客
03-29 2197
哈希介绍与哈希开散列实现
哈希表（散列表）原理详解
热门推荐
那年聪聪
06-03 29万+
哈希表（散列表）原理详解
Hash表 数据结构
jtabibito's blog
04-14 274
Hash 表key: valuekey 保存信息的唯一标识将char*类型的key转化为int型作为寻找信息的方式假设有10000个人, 分成100个表保存信息, 每个表保存100个人使用Hash算法对key做唯一标识计算// main.cpp #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;string.h&gt; ...
数据结构-hash表
yang1780409810的博客
01-15 229
什么是哈希表哈希表（散列表）是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录， 以加快查找的速度。这个映射函数叫做哈希...
数据结构哈希(hash)
wer24_25的博客
09-21 887
数据结构哈希(hash)的超详细介绍,感兴趣的宝子千万不要错过!!!
【数据结构】哈希（Hash）
秋之回忆Alex的博客
09-02 7628
数据结构：哈希函数
哈希Hash数据结构
刘皇叔说Java的博客
06-01 971
哈希表（Hash Table）是一种数据结构，用于实现键值对的存储和快速检索。它通过将键映射到数组的索引位置来实现高效的查找操作。哈希表通常由一个数组和一个哈希函数组成，哈希函数用于将键映射到数组索引位置。哈希函数：哈希函数是哈希表的核心，它接受一个键作为输入，并输出该键对应的哈希值。好的哈希函数应该能够将键均匀地映射到数组的不同位置，减少哈希冲突的发生。数组：哈希表的底层数据结构通常是一个数组，每个数组元素称为“桶”或“槽”，用于存储键值对。
数据结构 -- hash
巴基船长
07-15 206
hash定义效率分析数据存储reference 定义 哈希表（Hash Table，也叫散列表），是根据键（Key）而直接访问在内存存储位置的数据结构。 分为两个步骤： hash函数 通过一个关于键值的hash函数，得到所查询的数据映射到表中一个位置。 访问数据 不同的key 经过hash函数 可能计算得到相同的输出。此时叫做冲突，冲突的数据又成一个表。一般通过一个线性链表存储。访问时，遍历链表。 效率分析 插入数据：O(1) 查询数据：O(1)，最坏情况O (n) 数据存储 数组链表，hash 函数的
数据结构之哈希表（HASH）
编程随笔与杂谈
01-18 4万+
前言 　　　当我们在编程过程中，往往需要对线性表进行查找操作。在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。 　　　但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值