哈希

最新推荐文章于 2023-07-10 21:00:10 发布
最新推荐文章于 2023-07-10 21:00:10 发布
阅读量285 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZY_20181010/article/details/81206747
版权

哈希函数：是元素的存储位置与它的关键码之间能够建立一 一映射的关系，那么在查找时通过该函数可以很快找到该数据。 key

                  Hash (key) = key % m (m:存储单元的个数) 。

哈希冲突：对于两个数据元素的关键字K1和K2 (K1 ！= K2) ,但是有：HashFunc (ki) == HashFunc (Kj) ,函数即不同关键字通过相

                   同的哈希函数计算出相同的哈希地址，这种现象称为哈希冲突或哈希碰撞，把具有不同关键码而具有相同哈希地址

                   的数据元素称为“同义词”。

负载因子：a =填入表中的元素个数 / 散列表的长度

                   a ：散列表装满程度的因子，由于表长是定值，所以a与“填入表中的元素个数”成正比；实际上，散列表的平均查找长

                          度是负载因子a的函数，对于闭散列，负载因子特别重要，应严格控制在0.7 - 0.8以下。

哈希函数的构造方法：1.直接定制法。    2.除留余数法        3.数字分析法      4.折叠法

                                     5. 平方取中法      6.随机数法

常见哈希冲突的解决办法：1.闭散列（也称开放地址法）

                                              1）. 线性探测：从发生冲突的位置开始，依次继续向后探测，直到找到空位置为止。

                                               2）.二次探测（其实是二次方探测）

                                                    发生冲突时，二次探测法在查找“下一个”空位置的公式为：Hi = (H0 + i ^2) %m,  Hi =(H0 -                                                                i^2)%m,i =1,2,3,...(m -1)/2H0是通过散列函数Hash(x)对元素的关键码key进行计算的到的位                                                             置，m时表的大小。

                                             2.开散列（也称拉链法）。

                                              3.伪随机探测法

                                              4.再散列 （双重散列，多重散列）

                                              5. 建立一个公共溢出区

哈希表：

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
 
typedef int Key;
 
typedef int(*HashFunc)(Key, int);
 
typedef enum{
	EMPTY,
	EXIST,
	DELETED,
}State;
 
typedef struct Element{
	Key key;
	State state;
}Element;
 
typedef struct HashTable{
	Element *array;
	int size;
	int capacity;
	HashFunc hashFunc;
}HashTable;
 
void HTInit(HashTable *pHT, int capacity, HashFunc hashFunc)
{
	assert(pHT);
	pHT->array = (Element*)malloc(sizeof(Element)* capacity);
	assert(pHT->array);
	pHT->size = 0;
	pHT->capacity = capacity;
	pHT->hashFunc = hashFunc;
 
	for (int i = 0; i < capacity; i++)
	{
		pHT->array[i].state = EMPTY;
	}
}
 
int Search(HashTable *pHT, Key key)
{
	int index = pHT->hashFunc(key, pHT->capacity);
	int count = 1;
	while (pHT->array[index].state != EMPTY){
		if (pHT->array[index].key == key&&pHT->array[index].state == EXIST){
			return count;
		}
		index = (index + 1) % pHT->capacity;
		//哈希表因为负载因子的原因一般不会满
		count++;
	}
	return -1;
}
 
 
// 成功返回 1， 失败返回 -1
int Insert(HashTable *pHT, Key key)
{
	// TODO: 扩容
	//ExpandIfRequired(pHT);
 
	int index = pHT->hashFunc(key, pHT->capacity);
	int i = index;
	int count = 1;
	while (pHT->array[i].state == EXIST) {
		if (pHT->array[i].key == key && pHT->array[i].state == EXIST) {
			// 找到了
			return -1;
		}
 
		i = (index + count * count) % pHT->capacity;
		count++;
		//index = (index + 1) % pHT->capacity;	// 怎么实现循环
 
		// 隐患： 找了一圈都没找到，可能会死循环
	}
 
	// 这里开始插入
	pHT->array[i].key = key;
	pHT->array[i].state = EXIST;
	pHT->size++;
 
	return 1;
}
 
void ExpandIfRequired(HashTable *pHT)
{
	//哈希表需要考虑负载因子
	if (pHT->size * 10 / pHT->capacity < 7){
		return;
	}
	HashTable newHT;
	HTInit(&newHT, pHT->capacity * 2, pHT->hashFunc);
 
	for (int i = 0; i < pHT->capacity; i++){
		if (pHT->array[i].state == EXIST){
			Insert(&newHT,pHT->array[i].key);
		}
	}
	free(pHT->array);
	pHT->array = newHT.array;
	pHT->capacity = newHT.capacity;
}
 
// 成功返回 1，失败返回 -1
int Remove(HashTable *pHT, Key key)
{
	int index = pHT->hashFunc(key, pHT->capacity);
	while (pHT->array[index].state != EMPTY) {
		if (pHT->array[index].key == key && pHT->array[index].state == EXIST) {
			pHT->array[index].state = DELETED;
			pHT->size--;
			return 1;
		}
 
		index = (index + 1) % pHT->capacity;	// 怎么实现循环
 
		// 隐患： 找了一圈都没找到，可能会死循环
	}
 
	return -1;
}
 
void HTDestroy(HashTable *pHT)
{
	free(pHT->array);
}
 
int 除留余数法(Key key, int capacity)
{
	return key % capacity;
}
 
void Test()
{
	HashTable	ht;
	HTInit(&ht, 13, 除留余数法);
 
	Insert(&ht, 3);
	Insert(&ht, 7);
	Insert(&ht, 19);
	Insert(&ht, 25);
	Insert(&ht, 26);
	Insert(&ht, 6);
	Insert(&ht, 12);
	Insert(&ht, 39);
	Insert(&ht, 41);
	Insert(&ht, 32);
	Insert(&ht, 45);
}

哈希桶：

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

typedef char * Key;

typedef struct ListNode {
	Key	key;
	struct ListNode *pNext;
}	ListNode;

typedef struct Element {
	ListNode *	pFirst;
}	Element;

typedef int(*HashFunc)(Key, int);

typedef struct HashBucket {
	Element *array;
	int	size;
	int capacity;
	HashFunc hashFunc;
}	HashBucket;

void HBInit(HashBucket *pHB, int capacity, HashFunc hashFunc)
{
	pHB->array = (Element *)malloc(sizeof(Element)* capacity);
	assert(pHB->array);
	pHB->size = 0;
	pHB->capacity = capacity;
	pHB->hashFunc = hashFunc;

	// 所有地址初始化为 NULL
	memset(pHB->array, 0x0, sizeof(Element)* capacity);
}

// 插入，如果已经存在，插入失败返回 -1
// 否则插入成功，返回 1
int Insert(HashBucket *pHB, Key key);

// 返回正数表示找到，并且是查找次数
// 返回 -1 表示没有找到
int Search(HashBucket *pHB, Key key)
{
	int index = pHB->hashFunc(key, pHB->capacity);
	ListNode *pFirst = pHB->array[index].pFirst;
	ListNode *pNode;
	int count = 1;
	for (pNode = pFirst; pNode != NULL; pNode = pNode->pNext) {
		if (pNode->key == key) {
			return count;
		}
		count++;
	}

	return -1;
}

int ListSearch(ListNode *pFirst, Key key);
void ListPushFront(ListNode **ppFirst, Key key);

void ExpandIfRequired(HashBucket *pHB)
{
	// 哈希桶一般不考虑负载因子
	if (pHB->size < pHB->capacity) {
		return;
	}

	int newCapacity = pHB->capacity * 2;
	HashBucket newHB;
	HBInit(&newHB, newCapacity, pHB->hashFunc);

	// 整个哈希表里的数据到新哈希表里做插入
	// 首先遍历是顺序结构，其次遍历的是每个链表
	for (int i = 0; i < pHB->capacity; i++) {
		ListNode *pFirst = pHB->array[i].pFirst;
		ListNode *pNode = pFirst;
		for (; pNode; pNode = pNode->pNext) {

			// 真正要插入的
			Insert(&newHB, pNode->key);

		}
	}

	pHB->array = newHB.array;
	pHB->capacity = newCapacity;
}

// 插入，如果已经存在，插入失败返回 -1
// 否则插入成功，返回 1
int Insert(HashBucket *pHB, Key key)
{
	
	ExpandIfRequired(pHB);

	int index = pHB->hashFunc(key, pHB->capacity);

	if (ListSearch(pHB->array[index].pFirst, key) != -1) {
		return -1;
	}

	ListPushFront(&(pHB->array[index].pFirst), key);
	pHB->size++;

	return 1;
}

int ListSearch(ListNode *pFirst, Key key)
{
	ListNode *pNode;
	for (pNode = pFirst; pNode != NULL; pNode = pNode->pNext) {
		if (pNode->key == key) {
			return 1;
		}
	}

	return -1;
}

void ListPushFront(ListNode **ppFirst, Key key)
{
	ListNode *pNew = (ListNode *)malloc(sizeof(ListNode));
	assert(pNew);
	pNew->key = key;

	pNew->pNext = (*ppFirst);
	*ppFirst = pNew;
}

// 如果删除成功，返回 1
// 如果没有找到，删除失败，返回 -1
int Remove(HashBucket *pHB, Key key)
{
	int index = pHB->hashFunc(key, pHB->capacity);

	ListNode *pFirst = pHB->array[index].pFirst;
	ListNode *pNode, *pPrev = NULL;

	for (pNode = pFirst; pNode != NULL; pNode = pNode->pNext) {
		if (pNode->key == key) {
			pHB->size--;
			if (pNode == pFirst) {
				pHB->array[index].pFirst = pNode->pNext;
				free(pNode);
				return 1;
			}

			pPrev->pNext = pNode->pNext;
			free(pNode);
			return 1;
		}

		pPrev = pNode;
	}

	return -1;
}

int 除留余数法(Key key, int capacity)
{
	return 1;
	//return key % capacity;
}

位图：

#pragma once

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

typedef unsigned char uint8_t;
typedef unsigned int  uint32_t;

typedef struct BitArray{
	uint32_t *array;
	unsigned int capacity;//数组大小
	unsigned int size;
}BitArray;

void BitArrayInit(BitArray *pBA, unsigned int size)
{
	unsigned int capacity = size / 32;
	if (size %sizeof(uint32_t) != 0){
		capacity += 1;
	}

	//直接用calloc进行初始化为0
	pBA->array = (uint32_t *)calloc(sizeof(uint32_t), capacity);
	assert(pBA->array);

	pBA->capacity = capacity;
	pBA->size = size;
} 

void BitArrayDestroy(BitArray *pBA)
{
	free(pBA->array);
}

void Set1(BitArray *pBA, unsigned int which)
{
	unsigned int index = which / 32;
	unsigned int shift = which % 32;

	pBA->array[index] = pBA->array[index] | (1 << shift);
}

void Set0(BitArray *pBA, unsigned int which)
{
	unsigned int index = which / 32;
	unsigned int shift = which % 32;

	pBA->array[index] &= ~(1 << shift);
}

int IsSet(BitArray *pBA, unsigned int which)
{
	unsigned int index = which / 32;
	unsigned int shift = which % 32;

	return (pBA->array[index] & 1 << shift) >> shift;
}

void Test()
{
	BitArray ba;
	BitArrayInit(&ba, (unsigned int)-1);
	unsigned int array[] = { 3, 5, 7, 9 };

	for (unsigned int i = 0; i < sizeof(array) / sizeof(unsigned int); i++){
		Set1(&ba, array[i]);
	}

	unsigned int n = 8;
	printf("%d\n", IsSet(&ba, n));

	n = 9;
	printf("%d\n", IsSet(&ba, n));
}

 

ZY_20181010
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
哈希表的设计与实现【课程设计】
06-23
哈希表的设计与实现课程设计 问题描述：针对某个单位电话号码簿，设计一个哈希表，并完成相应的建表和查表程序。 基本要求：设每个记录有下列数据项：电话号码、用户名、住址。从键盘输入各记录，以用户名为关键字...
双向链表创建、删除某节点
u011559236的博客
10-17 1319
#include #include #include #define MAXLEN 10 typedef struct LinkNode { struct LinkNode * pNext; struct LinkNode * pPrev; int m_Value; }LINKNODE; void ShowLinkNode(LINKNODE * pHead) { if (NU
伪随机探究
weixin_42291052的博客
08-20 1400
伪随机探究 随机数发生器 我们很多的算法中需要随机数，因此必须有一种方法来产生它。同时我们也了解计算机的随机算法是一种伪随机。提前生成好随机序列，根据不同的随机种子函数，生成不同的随机数。 产生随机数最简单的方法就是线性同余数发生器。它于1951年有lehmer首先提出，对于一个Xi满足 X(i+1)=AXimodM； 为了开始这个序列，必须给Xi一个初值，这个值就叫种子（seed）。 人们可能会想到要假设所有的机器在它们标准的库中都有一个至少像不溢出随机数生成器的程序，但
数据结构与算法（六）
SiranTang的博客
04-18 597
C++ 数据结构与算法 后台开发 面试
数据结构：查找
u014765410的博客
06-06 1099
一、概念 **1、动态查找表/静态查找表：**若在查找的同时对表做修改操作（如插入和删除），则相应的表称之为 动态查找表，否则称为 静态查找表。 **2、平均查找长度(Average Search Length, ASL)：**为确定记录在查找表中的位置，需和给定值进行比较的关键字个数的期望值，称为查找算法在查找成功时的 平均查找长度。 二、线性表的查找 1、顺序查找 1）顺序查找(Sequent...
哈希算法总结及案例实现
m0_64529944的博客
07-10 871
哈希算法可用于验证数据完整性，具有防篡改检测的功能；常用的哈希算法有 MD5 、 SHA-1 等；用哈希存储口令时要考虑彩虹表攻击。Hmac 算法是一种标准的基于密钥的哈希算法，可以配合 MD5 、 SHA-1 等哈希算法，计算的摘要长度和原摘要算法长度相同。BouncyCastle 是一个开源的第三方算法提供商；BouncyCastle 提供了很多 Java 标准库没有提供的哈希算法和加密算法；
NT哈希破解
04-25
初学数据库和密码破解的好工具书，是一本很好的入门级书本，可以看看
java哈希遍历_哈希遍历_
09-29
哈希树遍历 HashMap遍历和使用 HashMap遍历和使用
获取哈希值
01-29
HashHash 获取哈希值获取哈希值获取哈希值获取哈希值获取哈希值
数据结构课设哈希表查找姓名.rar
09-23
问题描述：针对某个集体中人名设计哈希表，并完成相应的建表和查表程序。 要求： （1）假设人名为中国人姓名的汉语拼音形式。名称的长度不少于3个字符、不多于10个字符； （2）随机生成人名列表，个数不少于3000个，...
哈希算法C语言实现
02-17
哈希算法C语言实现
【数据结构】哈希（Hash）
秋之回忆Alex的博客
09-02 6064
数据结构：哈希函数
java 解决Hash(散列)冲突的四种方法--开放定址法(线性探测,二次探测,伪随机探测)、链地址法、再哈希、建立公共溢出区
热门推荐
请叫我大师兄
08-21 4万+
一）哈希表简介 非哈希表的特点：关键字在表中的位置和它之间不存在一个确定的关系，查找的过程为给定值一次和各个关键字进行比较，查找的效率取决于和给定值进行比较的次数。     哈希表的特点：关键字在表中位置和它之间存在一种确定的关系。 哈希函数：一般情况下，需要在关键字与它在表中的存储位置之间建立一个函数关系，以f(key)作为关键字为key的记录在表中的位置，通常称这个函数f
散列表-开地址法-线性探查法
家里蹲大学摸鱼学专业优秀毕业生的博客
12-30 665
#include<stdio.h> #include<stdlib.h> #define NewArray(k) (HashNode*)malloc((k)*sizeof(HashNode)) #define TRUE 1 #define FALSE 0 #define NeverUsed -9999 enum ResultCode {UnderFlow ,OverFlow, Success, Duplicate, NotPresent}; typedef struct ha
哈希算法详解
Pursuit_li的博客
02-01 1619
哈希(Hash)或者说散列表，它是一种基础数据结构。Hash 表是一种特殊的数据结构，它同数组、链表以及二叉排序树等相比较有很明显的区别，但它又是是数组和链表的基础上演化而来，既具有数组的有点，又具有链表的有点。能够快速定位到想要查找的记录，而不是与表中存在的记录的关键字进行比较来进行查找。应用了函数映射的思想将记录的存储位置与记录的关键字关联起来，从而能够很快速地进行查找。
理论基础 —— 查找 —— 哈希查找
Alex_McAvoy的博客
05-14 3184
【概述】 查找的理想情况是不经过任何比较，直接得出待查记录的存储位置，那么就需要在记录的存储位置与其关键码之间建立一个确定的对应关系 H，使得每个关键码 key 与唯一的存储位置 H(key) 相对应。 在查找时，根据这个确定关系找到给定值 k 和映射 H(k) ，若查找集合中存在这个记录，则必定在 H(k) 的位置上，这种查找技术即哈希查找（Hash Search），又称散列查找。 采用散...
哈希的介绍及实现
！
09-21 897
二者的用法与set和map是一样的，只不过不会对其数据进行排序。{{}}结果：99 3 9 5 2 4{dict.insert(make_pair("sort", "排序"));dict.insert(make_pair("left", "左边"));dict.insert(make_pair("left", "剩余"));dict["left"] = "剩余";dict["string"] = "字符串";{}}结果:sort-排序。
数据结构-----哈希表
u014682615的专栏
08-20 708
哈希表的基本思想：          以结点的关键字k为自变量，通过一个确定的函数关系f，计算出对应的函数值，并把这个值解释为结点的存储地址，最后将结点存入f(k)所指示的存储位置上。查找时再根据要查找的关键字，用同样的函数计算地址，然后从相应的单元中读取。函数f称为哈希函数，f(k)的值称为哈希地址，用于存储结点的数据结构称为哈希表。            几个概念：如果有哈希表的空间大小为
哈希-hash
pang_tuan的博客
07-26 5330
其实我们只需要收集模i余数在根号n范围内的sum[i][j]，如果我们输入的x＜根号n，那么我们O(1)输出sum[x][y]，否则我们用方法1，这个时候i+=x跨越度就非常大了，这样我们查询就分两类解决了。在此基础上，再建立一个溢出表，在之后的哈希操作中，无论关键字的同义词生成怎样的哈希地址，一旦发生冲突，就将其放入溢出表中。上例的整数我们用的10进制，如果把它迁移到一个字符串上，由于字符有26个，所以我们可以用一个大于26进制的进制来处理，一般选用131或1331或13331来作为字符串进制。...
python哈希举例
最新发布
03-31
Python中的哈希（hash）是将任意长度的输入通过哈希算法转换为固定长度的输出。Python中的哈希函数可以通过内置的`hash()`函数来调用。 下面是一个简单的例子，展示了如何使用哈希函数对字符串进行哈希： ```...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值