【数据结构】哈希桶

最新推荐文章于 2024-07-17 17:39:45 发布
原创 最新推荐文章于 2024-07-17 17:39:45 发布 · 291 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

文章目录

1.使用哈希桶处理整型数据

1）HashTableBucket.h

#ifndef  _HASHTABLEBUCKET_H__
#define _HASHTABLEBUCKET_H__





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

static size_t GetNextPrime(size_t value)
{
	int i = 0;
	//const int _PrimeSize = 28;
	static const unsigned long _PrimeList[28] =
	{
		53ul, 97ul, 193ul, 389ul, 769ul,
		1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
		49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
		1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
		50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
		1610612741ul, 3221225473ul, 4294967291ul
	};

	for (; i < 28; ++i)
	{
		if (_PrimeList[i] > value)
		{
			return _PrimeList[i];
		}
	}

	return _PrimeList[27];
}

static size_t StrHash(const char* str)
{
	size_t hash = 0;
	size_t seed = 131;
	while (*str)
	{
		/*hash += *str;*/
		hash = hash*seed + *str;
		++str;
	}

	/*printf("%u\n", hash);*/

	return hash;
}


typedef int HTBKeyType;
typedef int HTBValueType;

typedef struct HashNode
{
	struct HashNode* _next;
	HTBKeyType _key;
	HTBValueType _value;
}HashNode;

typedef struct HashTableBucket
{
	HashNode** _tables;
	size_t _size;
	size_t _len;
}HTB;

void HTBInit(HTB* htb, size_t len);
void HTBDestory(HTB* htb);

int HTBInsert(HTB* htb, HTBKeyType key, HTBValueType value);
int HTBRemove(HTB* htb, HTBKeyType key);
HashNode* HTBFind(HTB* htb, HTBKeyType key);

int HTBSize(HTB* htb);
int HTBEmpty(HTB* htb);



#endif

2）HashTableBucket.c


#include "HashTableBucket.h"

void HTBInit(HTB* htb, size_t len)
{
	assert(htb);
	//根据素数表获取哈希表的长度
	int HTB_len = GetNextPrime(len);
	//为哈希桶开辟空间(
	HashNode** table = (HashNode**)malloc(sizeof(HashNode*)*(HTB_len));
	if (table == NULL)
	{
		perror("use malloc of create");
		exit(EXIT_FAILURE);
	}
	htb->_tables = table;
	htb->_size = 0;
	htb->_len = HTB_len;
	//将哈希表中的所有指针初始化为空，否则会对野指针操作
	memset(htb->_tables,0, sizeof(HashNode*)*(htb->_len));
}

		

void HTBDestory(HTB* htb)
{
	unsigned int i = 0;
	assert(htb);

	for (; i < htb->_len; ++i)
	{
		HashNode* cur = htb->_tables[i];
		while (cur)
		{
			HashNode* next = cur->_next;
			free(cur);

			cur = next;
		}

		htb->_tables[i] = NULL;
	}

	free(htb->_tables);
	htb->_tables = NULL;
	htb->_size = 0;
	htb->_len = 0;
}



//哈希函数,计算哈希地址(整数)
static int HTBHashFunc(HTBKeyType key, int len)
{
  return key%len;
}


HashNode* BuyHashNode(HTBKeyType key, HTBValueType value)
{
	HashNode* node = malloc(sizeof(HashNode));
	if (node != NULL)
	{
		node->_key = key;
		node->_value = value;
		node->_next = NULL;
	}
	return node;
}

void HTBCheckCapacity(HTB* htb)
{
	assert(htb);
	if (htb->_size == htb->_len)
	{
		unsigned int i;
		HTB newhtb;
		newhtb._len = GetNextPrime(htb->_len);
		HTBInit(&newhtb, newhtb._len);
		if (htb->_size == htb->_len)
		{
			for (i = 0; i < htb->_len; ++i)
			{
				HashNode* cur = htb->_tables[i];
				while (cur)
				{
					//记录下一个结点的位置
					HashNode* next = cur->_next;
					size_t index = HTBHashFunc(cur->_key, newhtb._len);
					//头插到新的哈希表中
					cur->_next = newhtb._tables[index];
					newhtb._tables[index] = cur;

					cur = next;
				}

				htb->_tables[i] = NULL;
			}
		}

		HTBDestory(htb);

		htb->_tables = newhtb._tables;
		htb->_size = newhtb._size;
		htb->_len = newhtb._len;
	}
}

int HTBInsert(HTB* htb, HTBKeyType key, HTBValueType value)
{
	size_t index;
	HashNode* cur, *newNode;

	HTBCheckCapacity(htb);

	assert(htb);
	index = HTBHashFunc(key, htb->_len);
	cur = htb->_tables[index];
	while (cur)
	{
		if (cur->_key == key)
			return -1;

		cur = cur->_next;
	}

	newNode = BuyHashNode(key, value);
	newNode->_next = htb->_tables[index];
	htb->_tables[index] = newNode;
	htb->_size++;

	return 0;
}

int HTBRemove(HTB* htb, HTBKeyType key)
{
	size_t index;
	HashNode* cur = NULL, *prev = NULL;
	assert(htb);

	index = HTBHashFunc(key, htb->_len);
	cur = htb->_tables[index];
	while (cur)
	{
		if (cur->_key == key)
		{
			if (prev == NULL)
				htb->_tables[index] = cur->_next;
			else
				prev->_next = cur->_next;

			free(cur);
			--htb->_size;
			return 0;
		}

		prev = cur;
		cur = cur->_next;
	}

	return -1;
}

HashNode* HTBFind(HTB* htb, HTBKeyType key)
{
	size_t index;
	HashNode* cur;
	assert(htb);

	index = HTBHashFunc(key, htb->_len);
	cur = htb->_tables[index];
	while (cur)
	{
		if (cur->_key == key)
		{
			return cur;
		}

		cur = cur->_next;
	}

	return NULL;
}

int HTBSize(HTB* htb)
{
	assert(htb);
	return htb->_size == 0 ? 0 : 1;
}
int HTBEmpty(HTB* htb)
{
	assert(htb);
	return htb->_size == htb->_len ? 0 : 1;
}

void HTBPrint(HTB* htb)
{
	unsigned int i = 0;
	assert(htb);
	for (i=0; i < htb->_len; ++i)
	{
		int count = 0;
		
		printf("table[%d]->", i);
		HashNode* cur = htb->_tables[i];
		while (cur)
		{
			printf("([key:%d}:{value:%d])->", cur->_key, cur->_value);
			count++;
			cur = cur->_next;
		}

		
		printf("(count=%d)->over\n", count);

	}


}

3)Test.c

#include "HashTableBucket.h"




void HTBtest1()
{
	HTB htb;
	HTBInit(&htb, 10);
	HTBInsert(&htb, 6, 0);
	HTBInsert(&htb, 11, 0);
	HTBPrint(&htb);
}



int  main()
{
	HTBtest1();
	system("pause");
	return 0;
}

2.使用哈希桶处理字符数据

1）HashTableBucket.h

#ifndef  _HASHTABLEBUCKET_H__
#define _HASHTABLEBUCKET_H__





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

static size_t GetNextPrime(size_t value)
{
	int i = 0;
	//const int _PrimeSize = 28;
	static const unsigned long _PrimeList[28] =
	{
		53ul, 97ul, 193ul, 389ul, 769ul,
		1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
		49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
		1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
		50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
		1610612741ul, 3221225473ul, 4294967291ul
	};

	for (; i < 28; ++i)
	{
		if (_PrimeList[i] > value)
		{
			return _PrimeList[i];
		}
	}

	return _PrimeList[27];
}

static size_t StrHash(const char* str)
{
	size_t hash = 0;
	size_t seed = 131;
	while (*str)
	{
		/*hash += *str;*/
		hash = hash*seed + *str;
		++str;
	}

	/*printf("%u\n", hash);*/

	return hash;
}

//
typedef char* HTBKeyType;
typedef char* HTBValueType;

typedef struct HashNode
{
	struct HashNode* _next;
	HTBKeyType _key;
	HTBValueType _value;
}HashNode;

typedef struct HashTableBucket
{
	HashNode** _tables;
	size_t _size;
	size_t _len;
}HTB;

void HTBInit(HTB* htb, size_t len);
void HTBDestory(HTB* htb);

int HTBInsert(HTB* htb, HTBKeyType key, HTBValueType value);
int HTBRemove(HTB* htb, HTBKeyType key);
HashNode* HTBFind(HTB* htb, HTBKeyType key);

int HTBSize(HTB* htb);
int HTBEmpty(HTB* htb);



#endif

2）HashTableBucket.c


#include "HashTableBucket.h"

void HTBInit(HTB* htb, size_t len)
{
	assert(htb);
	//根据素数表获取哈希表的长度
	int HTB_len = GetNextPrime(len);
	//为哈希桶开辟空间(
	HashNode** table = (HashNode**)malloc(sizeof(HashNode*)*(HTB_len));
	if (table == NULL)
	{
		perror("use malloc of create");
		exit(EXIT_FAILURE);
	}
	htb->_tables = table;
	htb->_size = 0;
	htb->_len = HTB_len;
	//将哈希表中的所有指针初始化为空，否则会对野指针操作
	memset(htb->_tables,0, sizeof(HashNode*)*(htb->_len));
}

		

void HTBDestory(HTB* htb)
{
	unsigned int i = 0;
	assert(htb);

	for (; i < htb->_len; ++i)
	{
		HashNode* cur = htb->_tables[i];
		while (cur)
		{
			HashNode* next = cur->_next;
			free(cur);

			cur = next;
		}

		htb->_tables[i] = NULL;
	}

	free(htb->_tables);
	htb->_tables = NULL;
	htb->_size = 0;
	htb->_len = 0;
}

size_t HTBHashFunc(HTBKeyType key, size_t len)
{
	int count = 0;
	int i = 0;
	while (*(key + i) != '\0')
	{
		count += *(key + i);
		++i;
	}
	return count%len;
	
}

HashNode* BuyHashNode(HTBKeyType key, HTBValueType value)
{
	HashNode* node = malloc(sizeof(HashNode));
	if (node != NULL)
	{
		node->_key = key;
		node->_value = value;
		node->_next = NULL;
	}
	return node;
}

void HTBCheckCapacity(HTB* htb)
{
	assert(htb);
	if (htb->_size == htb->_len)
	{
		unsigned int i;
		HTB newhtb;
		newhtb._len = GetNextPrime(htb->_len);
		HTBInit(&newhtb, newhtb._len);
		if (htb->_size == htb->_len)
		{
			for (i = 0; i < htb->_len; ++i)
			{
				HashNode* cur = htb->_tables[i];
				while (cur)
				{
					//记录下一个结点的位置
					HashNode* next = cur->_next;
					size_t index = HTBHashFunc(cur->_key, newhtb._len);
					//头插到新的哈希表中
					cur->_next = newhtb._tables[index];
					newhtb._tables[index] = cur;

					cur = next;
				}

				htb->_tables[i] = NULL;
			}
		}

		HTBDestory(htb);

		htb->_tables = newhtb._tables;
		htb->_size = newhtb._size;
		htb->_len = newhtb._len;
	}
}

int HTBInsert(HTB* htb, HTBKeyType key, HTBValueType value)
{
	size_t index;
	HashNode* cur, *newNode;

	HTBCheckCapacity(htb);

	assert(htb);
	index = HTBHashFunc(key, htb->_len);
	cur = htb->_tables[index];
	while (cur)
	{
		if (cur->_key == key)
			return -1;

		cur = cur->_next;
	}

	newNode = BuyHashNode(key, value);
	newNode->_next = htb->_tables[index];
	htb->_tables[index] = newNode;
	htb->_size++;

	return 0;
}

int HTBRemove(HTB* htb, HTBKeyType key)
{
	size_t index;
	HashNode* cur = NULL, *prev = NULL;
	assert(htb);

	index = HTBHashFunc(key, htb->_len);
	cur = htb->_tables[index];
	while (cur)
	{
		if (cur->_key == key)
		{
			if (prev == NULL)
				htb->_tables[index] = cur->_next;
			else
				prev->_next = cur->_next;

			free(cur);
			--htb->_size;
			return 0;
		}

		prev = cur;
		cur = cur->_next;
	}

	return -1;
}

HashNode* HTBFind(HTB* htb, HTBKeyType key)
{
	size_t index;
	HashNode* cur;
	assert(htb);

	index = HTBHashFunc(key, htb->_len);
	cur = htb->_tables[index];
	while (cur)
	{
		if (cur->_key == key)
		{
			return cur;
		}

		cur = cur->_next;
	}

	return NULL;
}

int HTBSize(HTB* htb)
{
	assert(htb);
	return htb->_size == 0 ? 0 : 1;
}
int HTBEmpty(HTB* htb)
{
	assert(htb);
	return htb->_size == htb->_len ? 0 : 1;
}

void HTBPrint(HTB* htb)
{
	unsigned int i = 0;
	assert(htb);
	for (i=0; i < htb->_len; ++i)
	{
		int count = 0;
		
		printf("table[%d]->", i);
		HashNode* cur = htb->_tables[i];
		while (cur)
		{
			printf("([key:%s}:{value:%s])->", cur->_key, cur->_value);
			count++;
			cur = cur->_next;
		}

		
		printf("(count=%d)->over\n", count);

	}


}

3）Test.c

#include "HashTableBucket.h"


void HTBtest2()
{
	HTB htb;
	HTBInit(&htb, 10);

	HTBInsert(&htb, "insert", "插入");
	HTBInsert(&htb, "delete", "删除");
	HTBInsert(&htb, "hash", "哈希");
	HTBInsert(&htb, "test", "测试");

	HTBPrint(&htb);
}


int  main()
{
	HTBtest2();
	system("pause");
	return 0;
}
【数据结构】哈希表与哈希桶
℉f的博客
03-20 3387
本篇文章我们共同学习哈希结构，哈希结构追求更极致的搜索效率。之前学习的结构中搜索的效率取决于搜索过程中元素的比较次数，因此顺序结构中查找的时间复杂度为O(N)，平衡树中查找的时间复杂度为树的高度O(logN)。那我们能不能构建一种数据结构，让搜索效率达到O(1)呢。如果构造一种存储结构，该结构能够通过某种函数使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时就能通过该函数很快找到该元素进而达到O(1)的查找效率。接下来就让我们共同学习哈希结构。
数据结构——哈希表、哈希桶
mastershooter的博客
06-03 1639
此时，我们可根据哈希表的大小，选择其中各种符号分布均匀的若干位作为哈希地址。顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较，顺序查找时间复杂度为O(N),平衡树中为树的高度,即O(logN),搜索的效率取决于搜索过程种元素的比较次数。与闭散列的哈希表不同的是，在实现开散列的哈希表时，我们不用为哈希表中的每个位置设置一个状态字段，因为在开散列的哈希表中，我们将哈希地址相同的元素都放到了同一个哈希桶中，并不需要经过探测寻找所谓的“下一个位置”。
哈希表、哈希桶数据结构以及刨析HashMap源码中哈希桶的使用
ZJRUIII的博客
01-26 2586
文章目录一、哈希表1.哈希表概念2.冲突的概念3.避免冲突与解决冲突3.1 避免冲突的方式1——哈希函数的设计3.2 避免冲突的方式2——负载因子的调节3.3 解决冲突的方式1——闭散列3.4 解决冲突的方式2——开散列、哈希桶(重要)4.哈希表查找成功与查找失败的求法4.1 查找成功的求法4.2 查找失败的求法二、用泛型实现开散列与开散列在源码上的底层实现1.用泛型实现开散列2.开散列在源码上的底层实现2.1 HashMap底层面试题 一、哈希表 1.哈希表概念 可以不经过任何比较，一次直接从表中得到要搜
数据结构之哈希表（包含哈希桶）
无聊星期三的博客
05-15 7372
哈希表详解机器代码的实现。
数据结构--哈希表和哈希桶
sea18323的博客
02-19 1278
经过上面的分析所以，我们在最初的结构定义加上我们的状态定义,其中的HashFunc是用来处理不同类型的数据的，后面会讲解private ://封装数组 size_t _n = 0;//记录数据个数 };
数据结构——哈希
hu_143的博客
07-17 1752
数据结构——哈希新鲜出炉，快来围观吧~~~
哈希和哈希桶
TONGtongTONG000的博客
11-02 2187
概念 数据结构中有一类常用于搜索，给定一个元素集合，常见的可用于搜索的算法有 遍历，遍历是十分粗暴简单的手段，对于元素的集合没有特殊要求，时间复杂度是O(N)。效率通常较低。 二分查找，二分查找要求元素集合有序，时间复杂度为O(logN), 二叉搜索树，查找规则简单，但是退化为单支树时间复杂度是O(N), AVL树和红黑树，时间复杂度都是O(logN). 上面的这些常用的方法无一例外都有一个关键步骤就是元素的比较，通过比较待查找元素和集合中的元素，来确定该元素在集合中的位置。真实的效率取决于比较的次数。 如
数据结构之哈希查找方法
12-23
在哈希查找方法中，哈希表是核心数据结构，它通过一个数组实现，数组中的每个位置被称为哈希桶。哈希函数的作用是根据关键字计算出一个哈希值，该哈希值对应数组中的某个索引位置，理想情况下，不同的关键字通过哈希...
数据结构篇【5】——哈希表开散列实现（哈希桶）及封装
JayceSun的博客
06-28 533
在上一篇文章中我们解决哈希冲突的方法是闭散列，在本篇介绍另一种方法——开散列。在闭散列中如果我们碰到哈希冲突的时候我们采用的办法是向后查找，并占用另一个空余的位置，这种方法不好的地方就在于在不断的占用中哈希表的位置看起来好像没什么逻辑，而且容易产生“堆积”问题，导致查找元素的效率较低，另外我们始终要保证已经占用的位置不多于哈希表总大小的70%，因此还会造成较大的空间浪费。 开散列又叫链地址发（开链法、哈希桶），首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶
【数据结构七】哈希表
花铛
05-13 506
哈希表是一种非常重要的数据结构。几乎所有的编程语言都有直接或间接地应用这种数据结构。 哈希表通常是基于数组进行实现的，随机查找非常快速。 相对于数组，它的优点是可以提供非常快速地插入、删除和查找操作；缺点是哈希表中的数据是没有顺序的，并且 key 不允许重复。 数组进行插入操作，效率不高。 数组进行查找操作：如果是基于索引进行查找，效率非常高；如果是基于内容进行查找，效率不高。 数组进行删除操作，效率不高。 案例： 例如：现在有5000个单词，需要将这些单词使用某种数据结构保存起来，查找到单词之后可以获
哈希 ：哈希冲突、负载因子、哈希函数、哈希表、哈希桶
Jormungand_V的博客
08-29 4412
文章目录哈希哈希（散列）函数 哈希 哈希（散列）是一种数据结构，通过散列算法将元素值转换为散列值进行存储。使得元素存储的位置与元素本身建立起了映射关系，如果要查、改数据，就可以直接到对应的位置去，使得时间复杂度达到了 O(1)。 哈希（散列）函数 哈希函数就是建立起元素与其存储位置的映射关系。 对于哈希函数来说，必须具有以下特点; 哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0 到m-1之间 哈希函数计算出来的地址能均匀分布在整个空间中（防止产生密集的哈希冲突
数据结构之哈西表和哈西桶（含代码实现）
qq_56999918的博客
03-07 2341
1.哈西表的基本概念 散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(Hash）表，函数f(key)为哈希(Hash) 函数。------来自百度。 生活中有很多用到哈西表的地方比如说： .
哈希表的构造之线性探测法
qq_29503203的博客
11-08 6729
散列表，它是基于高速存取的角度设计的，也是一种典型的“空间换时间”的做法。顾名思义，该数据结构能够理解为一个线性表，可是当中的元素不是紧密排列的，而是可能存在空隙。 散列表（Hash table，也叫哈希表），是依据关键码值(Key value)而直接进行訪问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来訪问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列
HashTable—闭散列与开链法
zhangrrrr的博客
02-20 2382
哈希表，又称散列表，是搜索方法之一，其特点为根据关键字（key）直接访问在内存中的位置直接定址法 举一个例子，现在有如下一组字符char* arr[]={"hashtable"};接着定义一个大小为256的数组Hash，由于是字符型char，这些字符一定可以在这个数组中找到一个对应的位置进行插入；我们将这个表就成为哈希表，搜索时直接根据将自身作为下标便能搜索到所存位置； 而根据key又有两种方法
【数据结构】哈希表
某薛的黑猫
10-08 216
处理整型 头文件 #ifndef __HASHTABLE_H__ #define __HASHTABLE_H__ #include&amp;lt;stdio.h&amp;gt; #include&amp;lt;stdlib.h&amp;gt; #include&amp;lt;assert.h&amp;gt; #include &amp;lt;string.h&amp;gt; static size_t Get
哈希结构（图文详解）【哈希表，哈希桶，位图，布隆过滤器】
AllenSquirrel
05-29 7384
哈希结构 哈希概念 常见的K-V结构，实现了元素关键码与元素值的映射关系，但没有实现元素关键值与元素存储位置的映射关系，在遍历过程中，一般的顺序表或搜索二叉树要进行关键值的多次比较，其中顺序表的时间复杂度为O(n),二叉搜索树的时间复杂度O(lgn) 对此希望找到一种理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。 如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素 哈希
【数据结构】求两个有序单链表交集(差集)
某薛的黑猫
10-07 3890
交集 void UnionSetJ(pList list1, pList list2) { if (list1 == NULL || list2 == NULL) return; while (list1 &amp;amp;amp;amp;&amp;amp;amp;amp; list2) { if (list1-&amp;amp;amp;gt;data &amp;amp;amp;lt; list2-&amp;amp;amp;gt;data)
数据结构 哈希
最新发布
04-30
### 哈希数据结构的概念 哈希是一种通过特定算法将输入映射到固定长度输出的数据结构技术。其核心在于利用哈希函数将键值转换为存储地址，从而实现高效的插入、删除和查找操作[^1]。 #### 哈希表的核心特性 哈希表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值