数据结构---哈希表的认识

最新推荐文章于 2024-09-23 12:26:24 发布
最新推荐文章于 2024-09-23 12:26:24 发布
阅读量328 收藏
点赞数
分类专栏： 数据结构 文章标签： 哈希 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40421919/article/details/82944257
版权

哈希

  • 哈希概念

  • 顺序搜索以及二叉树搜索树中，元素存储位置和元素各关键码之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的 多次比较。搜索的效率取决于搜索过程中元素的比较次数。

  • 理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。

  • 如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通
    过该函数可以很快找到该元素。

  • 当向该结构中：

    • 插入元素时：根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
    • 搜索元素时：对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键 码相等，则搜索成功

  • 该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(Hash Table)(或者
    称散列表)

例如：数据集合{180，750，600，430，541，900，460}
在这里插入图片描述

  • 用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快
  • 问题：按照上述哈希方式，向集合中插入元素443，会出现什么问题？

哈希冲突

  • 对于两个数据元素的关键字 和 （i != j），有Ki ！= Kj，但有： HashFun(Ki) == HashFun(Kj)
  • 即不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。把具有不同关键码而具有相同哈希地 址的数据元素称为“同义词”。

发生哈希冲突该如何处理呢？

哈希函数

  • 引起哈希冲突的一个原因可能是：哈希函数设计不够合理。 哈希函数设计原则：
    • 哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间
    • 哈希函数计算出来的地址能均匀分布在整个空间中
    • 哈希函数应该比较简单

【常见哈希函数】

  • 直接定制法
  • 取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B
  • 优点：简单、均匀
  • 缺点：需要事先知道关键字的分布情况
  • 适合查找比较小且连续的情况
  • 面试题：找出一个字符串中第一个只出现一次的字符，要求：时间复杂度O(N)，空间复杂度O(1)
  • 除留余数法
  • 设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数：Hash(key) = key %
    p(p<=m),将关键码转换成哈希地址
  • 平方取中法
  • 假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址；
  • 再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址
  • 平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况
  • 折叠法
  • 折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表 长，取后几位作为散列地址
  • 折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况
  • 随机数法
  • 选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中random为随机数函数
  • 通常应用于关键字长度不等时采用此法
  • 数学分析法
  • 设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。例如：
    在这里插入图片描述
  • 假设要存储某家公司员工登记表，如果用手机号作为关键字，那么极有可能前7位都是 相同的，那么我们可以选择后面的四位作为散列地址，如果这样的抽取工作还容易出现 冲突，还可以对抽取出来的数字进行反转(如1234改成4321)、右环位移(如1234改成4123)、左环移位、前两数与后两数叠加(如1234改成12+34=46)等方法
  • 数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况

注意：哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突

处理哈希冲突

  • 解决哈希冲突两种常见的方法是：闭散列和开散列
  • 闭散列
  • 闭散列：也叫开放地址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到表中 “下一个”空位中去

那如何寻找下一个空余位置？

  • 线性探测

  • 设关键码集合为{37, 25, 14, 36, 49, 68, 57, 11}，散列表为HT[12]，表的大小m =
    12，假设哈希函数为：Hash(x) = x % p（p = 11，是最接近m的质数），就有：

  • Hash(37) = 4

  • Hash(25) = 3

  • Hash(14) = 3

  • Hash(36) = 3

  • Hash(49) = 5

  • Hash(68) = 2

  • Hash(57) = 2

  • Hash(11) = 0

  • 其中25，14，36以及68，57发生哈希冲突，一旦冲突必须要找出下一个空余位置

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

  • 【插入】

  • 1、使用哈希函数找到待插入元素在哈希表中的位置

  • 2、如果该位置中没有元素则直接插入新元素；如果该位置中有元素且和待插入元素相同，则不用插入；如果该位置中有元素但不是待插入元素则发生哈希冲突，使用线性探测找到下一个空位置，插入新元素；

  • 采用线性探测处理哈希冲突：
    在这里插入图片描述

  • 采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。为什么？那该 怎么来删除？

  • 采用线性探测，实现起来非常简单，缺陷是：

  • 一旦发生哈希冲突，所有的冲突连在一起，容易产生数据“堆积”，即：不同关键码占据了可利用的空位置，使得寻找某关键
    码的位置需要许多次比较，导致搜索效率降低。

  • 如何缓解呢？

  • 负载因子
    在这里插入图片描述

  • 二次探测

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

  • 假设数组的关键码为37, 25, 14, 36, 49, 68, 57, 11，取m =
    19，这样可设定为HT[19]，采用散列函数Hash(x) = x % 19，则：

    • Hash(37)=18
    • Hash(25)=6
    • Hash(14)=14
    • Hash(36)=17
    • Hash(49)=11
    • Hash(68)=11
    • Hash(57)=0
    • Hash(11)=11

  • 采用二次探测处理哈希冲突：
    在这里插入图片描述

  • 研究表明：当表的长度为质数且表装载因子a不超过0.5时，新的表项一定能够插入，而且任何一个位置都不会被探查两次。因此只
    要表中有一半的空位置，就不会存在表满的问题。在搜索时可以不考虑表装满的情况，但在插入时必须确保表的装载因子a不超过
    0.5；如果超出必须考虑增容

  • 开散列

  • 开散列法又叫链地址法(开链法)。

  • 开散列法：首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个
    桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。

  • 设元素的关键码为37, 25, 14, 36, 49, 68, 57, 11,
    散列表为HT[12]，表的大小为12，散列函数为Hash(x) = x % 11
    - Hash(37)=4
    - Hash(25)=3
    - Hash(14)=3
    - Hash(36)=3
    - Hash(49)=5
    - Hash(68)=2
    - Hash(57)=2
    - Hash(11)=0

  • 使用哈希函数计算出每个元素所在的桶号，同一个桶的链表中存放哈希冲突的元素。
    在这里插入图片描述

  • 通常，每个桶对应的链表结点都很少，将n个关键码通过某一个散列函数，存放到散列表中的m个桶中，那么每一个桶中链表的平均 长度为 n/m 。以搜索平均长度为 n/m 的链表代替了搜索长度为 n 的顺序表，搜索效率快的多。

  • 应用链地址法处理溢出，需要增设链接指针，似乎增加了存储开销。事实上：

  • 由于开地址法必须保持大量的空闲空间以确保搜索效率，如二次探查法要求装载因子a <= 0.7，而表项所占空间又比指针大的多，

  • 所以使用链地址法反而比开地址法节省存储空间

好了，废话了这么多，接下来该代码了，我实现了哈希的一个闭散列和一个开散列。

  • 多废话一句，哈希这块代码特别简单，主要是对于哈希的理解和自我的认识挺重要的。

  • 闭散列的代码实现

  • 首先是我定义的闭散列的结构体：由于我在哈希中存的是字符串，所以讲 char* 重定义成 HTDataType；对于存的所有元素还必须标明他的状态，所以我用枚举类型，分别定义，EMPTY为空，EXIST为存在，DELETE为删除。还有我们约定哈希表中所存元素都是唯一的。至于PDTInt 这个函数指针则是为了输出字符串在哈希表中所存的位置，到时候会在哈希函数中用到。结构体中 capacity 代表我的哈希表当前的容量，size 代表哈希表中有效的元素个数，也就是存在的元素，而 total 则代表的是哈希表中存在的元素和被删除的元素之和。注意：每个元素不仅仅要存元素，还要存这个元素的状态，因此我们用一个结构体来定义。

typedef char* HTDataType;
typedef int(*PDTInt)(HTDataType data);

typedef enum
{
	EMPTY,
	EXIST,
	DELETE
}State;

typedef struct HTElem
{
	HTDataType _data;
	State _state;
}HTElem;

// 约定：哈希表格中的元素是唯一的
typedef struct HashTable
{
	HTElem* _ht;
	int _capacity;
	int _size;  // 哈希表中有效元素的个数
	int _total; // EXIST 和 DELETE 
	PDTInt _PDTInt;

}HashTable, HT;
  • 初始化哈希表：没什么说的，日常操作
void InitHashTable(HT* pHT, int capacity, PDTInt pDTInt)
{
	assert(pHT);
	capacity = GetNextPrime(capacity);
	pHT->_ht = (HTElem*)malloc(capacity*sizeof(HTElem));
	if (!pHT->_ht)
	{
		assert(0);
		return;
	}
	for (int i = 0; i < capacity; i++)
		pHT->_ht[i]._state = EMPTY;

	pHT->_capacity = capacity;
	pHT->_PDTInt = pDTInt;
	pHT->_size = 0;
	pHT->_total = 0;
}
  • 检查哈希容量：由于闭散列中加入了负载因子，因此如果所存元素个数除以容量大于负载因子的话，就加大空间。否则就不动。如果开辟的话，那么原来空间的元素就需要插入到新的哈希表，其中只插入存在的元素即可。我说的重新插入可不是搬移，需要向哈希表中插元素一样，一个一个插，因为容量变化的话，不同的哈希表所对应的哈希函数所求的地址就会变。
  • 还有一点就是，我这儿用到线性探测和二次探测。总体来说，二次探测更好一些，因为线性探测如果一个位置发生“堵车”，那么接下来会越来越堵，时间复杂度会提高很多。
  • 还有别忘了，先释放旧空间，然后在将新开辟的空间赋过去。
void _CheckCapacity(HashTable* pHT)
{
	int hashAddr = 0;
	assert(pHT);
	if (pHT->_total / pHT->_capacity > 7)
	{
		int old_capacity = pHT->_capacity;
		int new_capacity = GetNextPrime(old_capacity * 2);
		HTElem* new_ht = (HTElem*)malloc(new_capacity*sizeof(HTElem));
		if (!new_ht)
		{
			assert(0);
			return;
		}

		for (int i = 0; i < new_capacity; i++)
			new_ht[i]._state = EMPTY;

		for (int i = 0; i < old_capacity; i++)
		{
			if (EXIST != pHT->_ht[i]._state)
				continue;

			hashAddr = HashFunc(pHT, pHT->_ht[i]._data);
#if 0
			if (EMPTY != pHT->_ht[i]._state)
			{
				//线性探测
				hashAddr++;
#else				

				//二次探测
				hashAddr = hashAddr + 2 * i + 1;
				if (hashAddr == new_capacity)
					hashAddr = 0;
#endif
			}
			new_ht[hashAddr]._data = pHT->_ht[i]._data;
			new_ht[hashAddr]._state = EXIST;
		}
		// 3. 释放就空间
		free(pHT->_ht);
		pHT->_ht = new_ht;
		pHT->_total = pHT->_size;
	}
}
  • 向哈希表中插入元素：这个函数最重要的是寻找要插入的位置，根据我们的约定，哈希表中不能出现重复元素，那么如果表中元素和插入元素有相同，就不插入。还有一点，插入之前应该先检查容量是否足够。

int InsertHashTable(HT* pHT, HTDataType data)
{
	assert(pHT);
	_CheckCapacity(pHT);
	int hasAddr = HashFunc(pHT, data);

	while (EXIST == pHT->_ht[hasAddr]._state)
	{
		if (EXIST == pHT->_ht[hasAddr]._state && data == pHT->_ht[hasAddr]._data)
			return 0;
#if 0
		//线性探测
		hasAddr++;
		if (hasAddr == pHT->_capacity)
			hasAddr = 0;
#else
		//二次探测
		int i = 0;
		hasAddr = hasAddr + 2*i + 1;
		hasAddr %= pHT->_capacity;
#endif	
	}
	pHT->_ht[hasAddr]._data = data;
	pHT->_ht[hasAddr]._state = EXIST;
	pHT->_size++;
	pHT->_total++;
	return 1;
}
  • 删除表中元素：实现这个功能我们可以用寻找表中元素这个函数，如果找不到那么就不删除，找到了就删除。
int DeleteHashTAble(HT* pHT, HTDataType data)
{
	int hasAddr = FindHashTable(pHT, data);
	if (-1 != hasAddr)
	{
		pHT->_ht[hasAddr]._state = DELETE;
		pHT->_size -= 1;
		return 1;
	}
	return 0;
}
  • 寻找一个表中元素：思路是利用哈希函数还有二次探测法找元素，找元素必须满足元素相等并且这个元素的状态必须是存在的。
int FindHashTable(HT* pHT, HTDataType data)
{
	int hasAddr = HashFunc(pHT, data);
	int i = 0;
	while (pHT->_ht[hasAddr]._state != EMPTY)
	{
		if (pHT->_ht[hasAddr]._state == EXIST && pHT->_ht[hasAddr]._data == data)
			return hasAddr;
	
#if 0
		//线性探测
		hasAddr++;
		if (hasAddr == pHT->_capacity)
			hasAddr = 0;
#else
		//二次探测
		hasAddr = hasAddr + 2 * i + 1;
		hasAddr %= pHT->_capacity;
#endif
	}
	return -1;
}
  • 哈希函数
int HashFunc(HashTable* pHT, HTDataType data)
{
	assert(pHT);
	return pHT->_PDTInt(data) % pHT->_capacity;
}
  • 下面的几个函数比较简单，我就不一一解释了，有判空函数；获取哈希表中元素个数；删除这个哈希表。
int EmptyHashTable(HT* pHT)
{
	assert(pHT);
	return 0 == pHT->_size;
}


int SizeHashTAble(HT* pHT)
{
	assert(pHT);
	return pHT->_size;
}

void DestroyHashTable(HashTable* pHT)
{
	free(pHT->_ht);
	pHT->_ht = NULL;
	pHT->_capacity = 0;
	pHT->_size = 0;
	pHT->_total = 0;
}
  • 经过研究发现，使用素数当做容量，可以有效的降低哈希冲突。那么我的容量就是用这个函数获取的。
unsigned long GetNextPrime(unsigned long prime)
{
	static unsigned long _PrimeList[PRIME_SIZE] =
	{
		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
	};

	int i = 0;
	for (; i < PRIME_SIZE; ++i)
	{
		if (_PrimeList[i] > prime)
			return _PrimeList[i];
	}

	return _PrimeList[PRIME_SIZE - 1];
}
  • 这个函数是将传进来的字符串转换成数字。用途就是讲存入哈希表中的字符串通过哈希函数变成在哈希表的位置。
unsigned long StrToINT(const char * str)
{
	unsigned int seed = 131; // 31 131 1313 13131 131313
	unsigned int hash = 0;
	while (*str)
	{
		hash = hash * seed + (*str++);
	}
	return (hash & 0x7FFFFFFF);
}
  • 我的测试函数

void TestHashTable()
{
	HashTable ht;
	InitHashTable(&ht, 10, StrToINT);
	InsertHashTable(&ht, "9527");
	InsertHashTable(&ht, "秋香");
	InsertHashTable(&ht, "石榴姐");
	InsertHashTable(&ht, "管家");

	printf("%d\n", SizeHashTAble(&ht));

	if (-1 != FindHashTable(&ht, "石榴姐"))
		printf("是 唐伯虎点秋香中的人物\n");
	else
		printf("不是 唐伯虎点秋香中的人物\n");

	if (-1 != FindHashTable(&ht, "轮轮"))
		printf("是 唐伯虎点秋香中的人物\n");
	else
		printf("不是 唐伯虎点秋香中的人物\n");

	DestroyHashTable(&ht);
}

开散列（也叫哈希桶）

  • 定义的结构体：用到链表就先封装一个链表。然后哈希表中存的是链表的头结点的地址。

typedef int HBDataType;

typedef struct HashBucketNode
{
	struct HashBucketNode* _pNext;
	HBDataType _data;
}Node, *PNode;


typedef struct HashBucket
{
	PNode* _table;
	int _capacity;
	int _size;
}HashBucket;
  • 初始化哈希桶：容量还是由获取素数函数决定，有一点就是，哈希桶放的元素是链表的头结点，那么刚开始的时候我们需要把头结点置为空。
void InitHashBucket(HashBucket* pHB, int capacity)
{
	assert(pHB);
	capacity = GetNextPrime(capacity);
	pHB->_table = (PNode*)malloc(capacity*sizeof(PNode));
	if (!pHB->_table)
	{
		assert(0);
		return;
	}

	for (int i = 0; i < capacity; i++)
		pHB->_table[i] = NULL;

	pHB->_size = 0;
	pHB->_capacity = capacity;
}
  • 向哈希表中插入元素：为元素在哈希桶找到位置后，我们采用链表的头插法来插入元素。注意一点就是插入时如果有相同元素就不插入，如果那个位置为空，就是那里还没有元素话，一定区别对待。
PNode BuyHashBucketNode(HBDataType data)
{
	PNode new_node = (PNode)malloc(sizeof(Node));
	if (!new_node)
	{
		assert(0);
		return;
	}
	new_node->_data = data;
	new_node->_pNext = NULL;

}

int InsertHashBucket(HashBucket* pHB, HBDataType data)
{
	assert(pHB);
	int bucketNo = HashFuncBucket(pHB, data);
	PNode pCur = pHB->_table[bucketNo];

	while (pCur != NULL)
	{
		if (data == pCur->_data)
			return 0;
		pCur = pCur->_pNext;
	}

	//头插法
	pCur = BuyHashBucketNode(data);
	pCur->_pNext = pHB->_table[bucketNo];
	pHB->_table[bucketNo] = pCur;
	pHB->_size++;
	return 1;
}
  • 删除哈希桶的一个节点：删除时一定要注意这个元素在哈希表中是否存在，还有就是被删除元素是头节点和其他节点需要区别对待。

int DeleteHashBucket(HashBucket* pHB, HBDataType data)
{
	int bucketNo = HashFuncBucket(pHB, data);
	PNode pCur = NULL;
	PNode pPrev = NULL;
	assert(pHB);

	pCur = pHB->_table[bucketNo];
	
	if (pCur == NULL)
		return 0;

	//删除头结点
	if (pCur->_data == data)
	{
		pHB->_table[bucketNo] = pCur->_pNext;
		free(pCur);
		pCur = NULL;
		pHB->_size--;
		return 1;
	}

	while (pCur != NULL) 
	{
		if (data == pCur->_data)
			break;
		pPrev = pCur;
		pCur = pCur->_pNext;
	}

	if (pCur == NULL)
		return 0;

	pPrev->_pNext = pCur->_pNext;
	free(pCur);
	pCur = NULL;
	pHB->_size--;
	return 1;
}
  • 在哈希表找一个元素：底层也就是链表的代码，没有什么说的。
int FindHashBucket(HashBucket* pHB, HBDataType data)
{
	assert(pHB);
	int bucketNo = HashFuncBucket(pHB, data);
	PNode pCur = NULL;

	pCur = pHB->_table[bucketNo];
	while (pCur != NULL)
	{
		if (data == pCur->_data)
			return 1;
		pCur = pCur->_pNext;
	}
	return 0;
}
  • 销毁整个哈希表：在销毁整个哈希表时我们需要注意，每一个桶中都是一条链表，因此需要我们注意，销毁完每一条链表后，在来销毁所有桶。
void MoveLinkList(PNode* pHead)
{
	PNode pCur = NULL;
	PNode pPrev = NULL;
	pCur = *pHead;
	while (pCur != NULL)
	{
		pPrev = pCur->_pNext;
		free(pCur);
		pCur = NULL;
		pCur = pPrev;
	}
}

int DestroyHashBucket(HashBucket* pHB, HBDataType data)
{
	assert(pHB);
	for (int i = 0; i < pHB->_capacity; i++)
	{
		MoveLinkList(&pHB->_table[i]);
	}
	free(pHB->_table);
	pHB->_table = NULL;
	pHB->_capacity = 0;
	pHB->_size = 0;
}
  • 哈希函数
int HashFuncBucket(HashBucket* pHB, HBDataType data)
{
	assert(pHB);
	return data %= pHB->_capacity;
}
  • 下面的两个小函数比较简单：一个判空函数和一个求哈希表中元素个数。
int EmptyHashBucket(HashBucket* pHB)
{
	assert(pHB);
	return 0 == pHB->_size;
}

int SizeHashBucket(HashBucket* pHB)
{
	assert(pHB);
	return pHB->_size;
}

 - 我的检测函数

void TestHashBucket()
{
HashBucket pHB;
InitHashBucket(&pHB, 10);

printf("哈希表%s空\n", EmptyHashBucket(&pHB) == 1 ? "为" : "不为");

printf("%s\n", InsertHashBucket(&pHB, 35) ? "插入成功" : "插入失败");
printf("%s\n", InsertHashBucket(&pHB, 87) ? "插入成功" : "插入失败");
printf("%s\n", InsertHashBucket(&pHB, 36) ? "插入成功" : "插入失败");
printf("%s\n", InsertHashBucket(&pHB, 90) ? "插入成功" : "插入失败");
printf("%s\n", InsertHashBucket(&pHB, 24) ? "插入成功" : "插入失败");
printf("%s\n", InsertHashBucket(&pHB, 46) ? "插入成功" : "插入失败");
printf("%s\n", InsertHashBucket(&pHB, 12) ? "插入成功" : "插入失败");
printf("%s\n", InsertHashBucket(&pHB, 12) ? "插入成功" : "插入失败");
printf("%s\n", InsertHashBucket(&pHB, 99) ? "插入成功" : "插入失败");
printf("%s\n", InsertHashBucket(&pHB, 99) ? "插入成功" : "插入失败");
printf("%s\n", InsertHashBucket(&pHB, 99) ? "插入成功" : "插入失败");


printf("哈希表%s空\n", EmptyHashBucket(&pHB) == 1 ? "为" : "不为");
printf("哈希表中元素个数：%d \n", SizeHashBucket(&pHB));

printf("%s\n", FindHashBucket(&pHB, 24) ? "找到了" : "没找到");
printf("%s\n", FindHashBucket(&pHB, 46) ? "找到了" : "没找到");
printf("%s\n", FindHashBucket(&pHB, 120) ? "找到了" : "没找到");

printf("%s\n", DeleteHashBucket(&pHB, 24) ? "删除成功" : "删除失败");
printf("%s\n", DeleteHashBucket(&pHB, 46) ? "删除成功" : "删除失败");
printf("%s\n", DeleteHashBucket(&pHB, 100) ? "删除成功" : "删除失败");

printf("%s\n", FindHashBucket(&pHB, 24) ? "找到了" : "没找到");
printf("%s\n", FindHashBucket(&pHB, 46) ? "找到了" : "没找到");
printf("%s\n", FindHashBucket(&pHB, 120) ? "找到了" : "没找到");

}

最后我附上我的所有代码

common.h


#define PRIME_SIZE  28
unsigned long GetNextPrime(unsigned long prime);
unsigned long StrToINT(const char * str);




unsigned long GetNextPrime(unsigned long prime)
{
	static unsigned long _PrimeList[PRIME_SIZE] =
	{
		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
	};

	int i = 0;
	for (; i < PRIME_SIZE; ++i)
	{
		if (_PrimeList[i] > prime)
			return _PrimeList[i];
	}

	return _PrimeList[PRIME_SIZE - 1];
}


unsigned long StrToINT(const char * str)
{
	unsigned int seed = 131; // 31 131 1313 13131 131313
	unsigned int hash = 0;
	while (*str)
	{
		hash = hash * seed + (*str++);
	}
	return (hash & 0x7FFFFFFF);
}

闭散列 HashTable.h

#pragma once
#include<assert.h>
#include<stdio.h>
#include<stdlib.h>
#include"common.h"

//typedef int HTDataType;
typedef char* HTDataType;
typedef int(*PDTInt)(HTDataType data);

typedef enum
{
	EMPTY,
	EXIST,
	DELETE
}State;

typedef struct HTElem
{
	HTDataType _data;
	State _state;
}HTElem;

// 约定：哈希表格中的元素是唯一的
typedef struct HashTable
{
	HTElem* _ht;
	int _capacity;
	int _size;  // 哈希表中有效元素的个数
	int _total; // EXIST 和 DELETE 
	PDTInt _PDTInt;

}HashTable, HT;



void InitHashTable(HT* pHT, int capacity, PDTInt pDTInt);
int InsertHashTable(HT* pHT, HTDataType data);
int DeleteHashTAble(HT* pHT, HTDataType data);
int FindHashTable(HT* pHT, HTDataType data);
int EmptyHashTable(HT* pHT);
int SizeHashTAble(HT* pHT);
int HashFunc(HashTable* pHT, HTDataType data);
void _CheckCapacity(HashTable* pHT);
void DestroyHashTable(HashTable* pHT);



void InitHashTable(HT* pHT, int capacity, PDTInt pDTInt)
{
	assert(pHT);
	capacity = GetNextPrime(capacity);
	pHT->_ht = (HTElem*)malloc(capacity*sizeof(HTElem));
	if (!pHT->_ht)
	{
		assert(0);
		return;
	}
	for (int i = 0; i < capacity; i++)
		pHT->_ht[i]._state = EMPTY;

	pHT->_capacity = capacity;
	pHT->_PDTInt = pDTInt;
	pHT->_size = 0;
	pHT->_total = 0;
}

void _CheckCapacity(HashTable* pHT)
{
	int hashAddr = 0;
	assert(pHT);
	if (pHT->_total / pHT->_capacity > 7)
	{
		int old_capacity = pHT->_capacity;
		int new_capacity = GetNextPrime(old_capacity * 2);
		HTElem* new_ht = (HTElem*)malloc(new_capacity*sizeof(HTElem));
		if (!new_ht)
		{
			assert(0);
			return;
		}

		for (int i = 0; i < new_capacity; i++)
			new_ht[i]._state = EMPTY;

		for (int i = 0; i < old_capacity; i++)
		{
			if (EXIST != pHT->_ht[i]._state)
				continue;

			hashAddr = HashFunc(pHT, pHT->_ht[i]._data);

			if (EMPTY != pHT->_ht[i]._state)
			{
				//线性探测
				hashAddr++;
				

				//二次探测
				hashAddr = hashAddr + 2 * i + 1;
				if (hashAddr == new_capacity)
					hashAddr = 0;
			}
			new_ht[hashAddr]._data = pHT->_ht[i]._data;
			new_ht[hashAddr]._state = EXIST;
		}
		// 3. 释放就空间
		free(pHT->_ht);
		pHT->_ht = new_ht;
		pHT->_total = pHT->_size;
	}
}

int InsertHashTable(HT* pHT, HTDataType data)
{
	assert(pHT);
	_CheckCapacity(pHT);
	int hasAddr = HashFunc(pHT, data);

	while (EXIST == pHT->_ht[hasAddr]._state)
	{
		if (EXIST == pHT->_ht[hasAddr]._state && data == pHT->_ht[hasAddr]._data)
			return 0;
#if 0
		//线性探测
		hasAddr++;
		if (hasAddr == pHT->_capacity)
			hasAddr = 0;
#else
		//二次探测
		int i = 0;
		hasAddr = hasAddr + 2*i + 1;
		hasAddr %= pHT->_capacity;
#endif	
	}
	pHT->_ht[hasAddr]._data = data;
	pHT->_ht[hasAddr]._state = EXIST;
	pHT->_size++;
	pHT->_total++;
	return 1;
}


int DeleteHashTAble(HT* pHT, HTDataType data)
{
	int hasAddr = FindHashTable(pHT, data);
	if (-1 != hasAddr)
	{
		pHT->_ht[hasAddr]._state = DELETE;
		pHT->_size -= 1;
		return 1;
	}
	return 0;
}


int FindHashTable(HT* pHT, HTDataType data)
{
	int hasAddr = HashFunc(pHT, data);
	int i = 0;
	while (pHT->_ht[hasAddr]._state != EMPTY)
	{
		if (pHT->_ht[hasAddr]._state == EXIST && pHT->_ht[hasAddr]._data == data)
			return hasAddr;
	
#if 0
		//线性探测
		hasAddr++;
		if (hasAddr == pHT->_capacity)
			hasAddr = 0;
#else
		//二次探测
		hasAddr = hasAddr + 2 * i + 1;
		hasAddr %= pHT->_capacity;
#endif
	}
	return -1;
}


int EmptyHashTable(HT* pHT)
{
	assert(pHT);
	return 0 == pHT->_size;
}


int SizeHashTAble(HT* pHT)
{
	assert(pHT);
	return pHT->_size;
}


int HashFunc(HashTable* pHT, HTDataType data)
{
	assert(pHT);
	return pHT->_PDTInt(data) % pHT->_capacity;
}

void DestroyHashTable(HashTable* pHT)
{
	free(pHT->_ht);
	pHT->_ht = NULL;
	pHT->_capacity = 0;
	pHT->_size = 0;
	pHT->_total = 0;
}

void TestHashTable()
{
	HashTable ht;
	InitHashTable(&ht, 10, StrToINT);
	InsertHashTable(&ht, "9527");
	InsertHashTable(&ht, "秋香");
	InsertHashTable(&ht, "石榴姐");
	InsertHashTable(&ht, "管家");

	printf("%d\n", SizeHashTAble(&ht));

	if (-1 != FindHashTable(&ht, "石榴姐"))
		printf("是 唐伯虎点秋香中的人物\n");
	else
		printf("不是 唐伯虎点秋香中的人物\n");

	if (-1 != FindHashTable(&ht, "轮轮"))
		printf("是 唐伯虎点秋香中的人物\n");
	else
		printf("不是 唐伯虎点秋香中的人物\n");

	DestroyHashTable(&ht);
}

开散列 HashBucket.h

#pragma once
#include<assert.h>
#include<stdio.h>
#include<stdlib.h>
#include"common.h"

typedef int HBDataType;

typedef struct HashBucketNode
{
	struct HashBucketNode* _pNext;
	HBDataType _data;
}Node, *PNode;


typedef struct HashBucket
{
	PNode* _table;
	int _capacity;
	int _size;
}HashBucket;


void InitHashBucket(HashBucket* pHB, int capacity);
int InsertHashBucket(HashBucket* pHB, HBDataType data);
int DeleteHashBucket(HashBucket* pHB, HBDataType data);
int FindHashBucket(HashBucket* pHB, HBDataType data);
int EmptyHashBucket(HashBucket* pHB);
int SizeHashBucket(HashBucket* pHB);
int DestroyHashBucket(HashBucket* pHB, HBDataType data);
int HashFuncBucket(HashBucket* pHB, HBDataType data);
PNode BuyHashBucketNode(HBDataType data);



void InitHashBucket(HashBucket* pHB, int capacity)
{
	assert(pHB);
	capacity = GetNextPrime(capacity);
	pHB->_table = (PNode*)malloc(capacity*sizeof(PNode));
	if (!pHB->_table)
	{
		assert(0);
		return;
	}

	for (int i = 0; i < capacity; i++)
		pHB->_table[i] = NULL;

	pHB->_size = 0;
	pHB->_capacity = capacity;
}


PNode BuyHashBucketNode(HBDataType data)
{
	PNode new_node = (PNode)malloc(sizeof(Node));
	if (!new_node)
	{
		assert(0);
		return;
	}
	new_node->_data = data;
	new_node->_pNext = NULL;

}

int InsertHashBucket(HashBucket* pHB, HBDataType data)
{
	assert(pHB);
	int bucketNo = HashFuncBucket(pHB, data);
	PNode pCur = pHB->_table[bucketNo];

	while (pCur != NULL)
	{
		if (data == pCur->_data)
			return 0;
		pCur = pCur->_pNext;
	}

	//头插法
	pCur = BuyHashBucketNode(data);
	pCur->_pNext = pHB->_table[bucketNo];
	pHB->_table[bucketNo] = pCur;
	pHB->_size++;
	return 1;
}


int DeleteHashBucket(HashBucket* pHB, HBDataType data)
{
	int bucketNo = HashFuncBucket(pHB, data);
	PNode pCur = NULL;
	PNode pPrev = NULL;
	assert(pHB);

	pCur = pHB->_table[bucketNo];
	
	if (pCur == NULL)
		return 0;

	//删除头结点
	if (pCur->_data == data)
	{
		pHB->_table[bucketNo] = pCur->_pNext;
		free(pCur);
		pCur = NULL;
		pHB->_size--;
		return 1;
	}

	while (pCur != NULL) 
	{
		if (data == pCur->_data)
			break;
		pPrev = pCur;
		pCur = pCur->_pNext;
	}

	if (pCur == NULL)
		return 0;

	pPrev->_pNext = pCur->_pNext;
	free(pCur);
	pCur = NULL;
	pHB->_size--;
	return 1;
}

int FindHashBucket(HashBucket* pHB, HBDataType data)
{
	assert(pHB);
	int bucketNo = HashFuncBucket(pHB, data);
	PNode pCur = NULL;

	pCur = pHB->_table[bucketNo];
	while (pCur != NULL)
	{
		if (data == pCur->_data)
			return 1;
		pCur = pCur->_pNext;
	}
	return 0;
}


int EmptyHashBucket(HashBucket* pHB)
{
	assert(pHB);
	return 0 == pHB->_size;
}

int SizeHashBucket(HashBucket* pHB)
{
	assert(pHB);
	return pHB->_size;
}

void MoveLinkList(PNode* pHead)
{
	PNode pCur = NULL;
	PNode pPrev = NULL;
	pCur = *pHead;
	while (pCur != NULL)
	{
		pPrev = pCur->_pNext;
		free(pCur);
		pCur = NULL;
		pCur = pPrev;
	}
}

int DestroyHashBucket(HashBucket* pHB, HBDataType data)
{
	assert(pHB);
	for (int i = 0; i < pHB->_capacity; i++)
	{
		MoveLinkList(&pHB->_table[i]);
	}
	free(pHB->_table);
	pHB->_table = NULL;
	pHB->_capacity = 0;
	pHB->_size = 0;
}

int HashFuncBucket(HashBucket* pHB, HBDataType data)
{
	assert(pHB);
	return data %= pHB->_capacity;
}

void TestHashBucket()
{
	HashBucket pHB;
	InitHashBucket(&pHB, 10);

	printf("哈希表%s空\n", EmptyHashBucket(&pHB) == 1 ? "为" : "不为");
	
	printf("%s\n", InsertHashBucket(&pHB, 35) ? "插入成功" : "插入失败");
	printf("%s\n", InsertHashBucket(&pHB, 87) ? "插入成功" : "插入失败");
	printf("%s\n", InsertHashBucket(&pHB, 36) ? "插入成功" : "插入失败");
	printf("%s\n", InsertHashBucket(&pHB, 90) ? "插入成功" : "插入失败");
	printf("%s\n", InsertHashBucket(&pHB, 24) ? "插入成功" : "插入失败");
	printf("%s\n", InsertHashBucket(&pHB, 46) ? "插入成功" : "插入失败");
	printf("%s\n", InsertHashBucket(&pHB, 12) ? "插入成功" : "插入失败");
	printf("%s\n", InsertHashBucket(&pHB, 12) ? "插入成功" : "插入失败");
	printf("%s\n", InsertHashBucket(&pHB, 99) ? "插入成功" : "插入失败");
	printf("%s\n", InsertHashBucket(&pHB, 99) ? "插入成功" : "插入失败");
	printf("%s\n", InsertHashBucket(&pHB, 99) ? "插入成功" : "插入失败");


	printf("哈希表%s空\n", EmptyHashBucket(&pHB) == 1 ? "为" : "不为");
	printf("哈希表中元素个数：%d \n", SizeHashBucket(&pHB));

	printf("%s\n", FindHashBucket(&pHB, 24) ? "找到了" : "没找到");
	printf("%s\n", FindHashBucket(&pHB, 46) ? "找到了" : "没找到");
	printf("%s\n", FindHashBucket(&pHB, 120) ? "找到了" : "没找到");

	printf("%s\n", DeleteHashBucket(&pHB, 24) ? "删除成功" : "删除失败");
	printf("%s\n", DeleteHashBucket(&pHB, 46) ? "删除成功" : "删除失败");
	printf("%s\n", DeleteHashBucket(&pHB, 100) ? "删除成功" : "删除失败");

	printf("%s\n", FindHashBucket(&pHB, 24) ? "找到了" : "没找到");
	printf("%s\n", FindHashBucket(&pHB, 46) ? "找到了" : "没找到");
	printf("%s\n", FindHashBucket(&pHB, 120) ? "找到了" : "没找到");

}

主函数

#define _CRT_SECURE_NO_WARNINGS 1
//#include"hashTable.h"
#include"hashBucket.h"
int main()
{
	//TestHashTable();
	TestHashBucket();
	return 0;
}

哈希时数据结构这儿的重点，以上我总结的比较乱，如果发现错误，欢饮下方讨论。

深入哈希表（三）--拉链法（哈希桶）实现哈希表
ArchyLi
11-11 3340
一、简介为了解决线性探构造哈希表所出现的大量哈希冲突，我们采用了另外一种方法，便是开链法。而在SGI版本的STL中调用的也正是哈希桶的实现方法。注意：开链法实现哈希表的时候会出现很多很多的错误，比如各种模板错误，此时需要耐心，慢慢调整。同时又为了扩展hash_map与hash_set更改了一些模板参数，所以经过调试错误的过程，绝对会对模板有一个全新的认识。二、拉链法实现原理：采用了由N个头指针构成的
数据结构与算法 — 认识哈希表、地址的冲突、链地址法、开放地址法、哈希化的效率
m0_59897687的博客
01-09 3333
目录 一. 认识哈希表 1.哈希化 2.哈希函数 3.哈希表 二. 地址的冲突 三、链地址法（拉链法） 四、开放地址法 1.线性探测 2.二次探测 3.再哈希法 五、哈希化的效率 1.装填因子 2.开放地址法 (1).线性探测 (2).二次探测和再哈希 3.链地址法 一. 认识哈希表 哈希表是一种非常重要的数据结构，几乎所有的编程语言都有直接或者间接的应用这种数据结构。 ...
哈希表的理解
weixin_30415113的博客
04-15 173
哈希表是种数据结构，它可以提供快速的插入操作和查找操作。第一次接触哈希表时，它的优点多得让人难以置信。不论哈希表中有多少数据，插入和删除（有时包括侧除）只需要接近常量的时间即0(1）的时间级。实际上，这只需要几条机器指令。 　　对哈希表的使用者一一人来说，这是一瞬间的事。哈希表运算得非常快，在计算机程序中，如果需要在一秒种内查找上千条记录通常使用哈希表（例如拼写检查器)哈希表的速度明显...
哈希表的初步认识
wind1_rain的博客
06-26 290
哈希表 - 幕布 哈希表诞生的前提在线性表、树等数据结构中，记录在结构中的相对位置是随机的，和记录的关键字之间不存在确定的关系，因此， 在结构中查找记录时需要进行一系列和关键字的比较。此类的查找方法建立在"比较"的基础上。在顺序查找时，比较的结果为等于 与 不等于两种可能；在折半查找中、二叉排序树查找和B-树查找时，比较的结果为小于、等于、和大于三种可能；查找的效率依赖于查找过程中所进行的比较次数。定义：理想的情况，希望不经过任何比较，一次存取便能得到所查记录，那就必须在记录的存储位置和它...
【C++】哈希桶
最新发布
Cayyyy的博客
09-23 2831
哈希桶是哈希表中用于存储数据的基本单元，也称为哈希槽或存储桶。
哈希表的初步认知
Nessie_zhao的博客
05-28 542
首先我们来认识一下什么是哈希表？？ 哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(...
哈希表简单认识
小陈的博客
07-01 246
哈希值是由十进制数构成的值，在Java中根据对象的物理地址和属性、方法等映射出来的一个值（模拟的逻辑地址，并不是一个实际的存储物理地址），也就是说两个对象物理地址相同哈希值一定相同，但是哈希值相同的两个对象物理地址并不一定相同。在Java中哈希值可以通过Object的hashCode的方法获取在java中所有的引用类型每个引用都有相应的哈希值包括数组作用：提升查询数据的速度哈希表数其实是一种数据结构，在java中哈希表就是一个存放着哈希值通过哈希函数映射出来一个个值的数组。只是数组存放的是单一的数据，而哈希
Hash表的初步认识
qq_51194826的博客
03-30 510
简介 哈希表(hash table）也叫作散列表,作为数据结构的一种,它的优点在于无论是插入操作还是查找操作,它的时间复杂度是o(1),正是因为这个优点,在海量数据处理的场景都会有它的身影. 这其中的Hash也就是hash值,主要用于信息安全领域的加密算法,它把一些值转换为杂乱的128编码,这些编码值就叫做Hash值,换个方向去看这个Hash值,Hash就是一种数据与数据地址之间的映射关系. 对java源代码有一定的理解的同学，HashSet的底层代码原理是HashMap,而HashMap的底层原理就主要就
数据结构 C语言 哈希表.docx
03-28
### 数据结构：C语言实现哈希表 #### 核心知识点概述 本篇文章将围绕一个C语言中的哈希表实现案例展开，详细解析哈希表的基本概念、设计思路及其实现过程。通过阅读本文，您将了解到哈希表在C语言编程中的应用，并...
山东大学软件学院2018-2019 数据结构真题
01-10
数据结构是计算机科学中的核心课程，它探讨了如何在计算机中高效地组织和操作数据。在山东大学软件学院2018-2019的数据结构考试中，涉及了线性结构、...通过解决这些问题，学生可以深化对数据结构原理和算法的认识。
2017-2020年重庆邮电大学802数据结构考研真题
03-06
1. **基本概念**：首先，考生需要对基本的数据结构类型有清晰的认识，包括数组、链表、栈、队列、树（二叉树、平衡树如AVL树、红黑树等）、图等。理解它们的特点、操作方式以及适用场景。 2. **算法设计与分析**：...
对哈希表的一些理解
nydcc的博客
04-12 187
哈希表浅谈 哈希表通俗来说是将数据以某种规则计算来取到一个关键值key，然后查找时直接通过关键值key直接找到数据，这样平均情况下时间复杂度为O(1)。但是因为规则并不是万能的，所以会使得不同的数据得出的关键值一样，产生冲突。解决冲突的方法有两种，一个方法是为冲突关键字在哈希表中寻找另一个位置，称开放寻址法，一个方法是把在相同位置的所有关键字都存储在一个“挂”在那个位置上的数据结构中，称...
哈希表理解
weixin_44039506的博客
04-03 599
哈希表什么是哈希表？哈希表怎么存储数据的？哈希冲突处理哈希冲突哈希表的扩容哈希表怎么读取数据 什么是哈希表？ 百度百科： 散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 给定表M，存在函数f(key)，对任意给定...
对哈希表的理解
lihuadaiyu26的博客
05-07 300
哈希表（散列表）哈希函数：key与value地址的映射关系                value地址 = Hash(key)value地址对数组长度取余，可以得到连续的index其结构可如图所示：查找、插入、删除的时间复杂度为O(1)...
数据结构---哈希
qq_48983250的博客
03-09 386
1.哈希 Hash 哈希函数 == 散列函数 将数据自身的值 和 最终的存储位置 形成一个特定关系，这个关系叫做hash函数 y（存储位置） = f（x（关键值key）） 2.如何构造哈希（6种） （1）直接定址法 （2）数字分析法 （3）平方取中法 （4）折叠法 （5）除留余数法 （6）随机数法 最经常的构造方法：除留余数法 哈希表：hash table 哈希表 哈希函数 哈希是一种存储方法 哈希是一种排序方法 哈希的存储方法是面向排序方法创建的 只要算法中用到了哈希思想，这个算法就可以叫做hash算法
数据结构----哈希
li94263的博客
03-18 1040
哈希函数的构造方法： 1、直接定址法 2、数字分析法 3、折叠法 4、除留余数法 5、随机数法 6、平方取中法 如何处理哈希冲突： 1、开放地址法 2、再散列函数法 3、链地址法 4、公共区溢出法 ...
哈希表的简单理解
aosimth的博客
05-26 478
哈希表具有查询速度快，效率高的优点，是基于数组，特定情况下结合链表（红黑树）的数据结构。 设计思路： 设想用数组存储英文字母a-zzzzzzzz的字符串，这样的话总共有26^8种结果，而如果想要查询字母absdaw就只能通过遍历数组，非常影响速度。 灵感一闪而过，如果能把每个字母与数组下标绑定不就能快速查询，而每个字符都有一个唯一特定的ASCII值 思路1：提取字母的每个字符，转为ASCII值后相加 public int wordToNum(String word){ int tota
哈希表查找的本质
认知 行动 坚持
08-01 3119
某一天，黄药师、欧阳锋、周伯通、郭靖、洪七公、一灯大师入住酒店，每人一个房间。 江南七怪柯镇恶，要去酒店找郭靖，怎么找呢？线性查找的思路是：逐个房间敲门询问，直到找到郭靖为止。 对于初入门编程的人来说，这是最直接的思路，而且好像不容易找到其它思路。 然而，对于稍有点生活常识的人来说，线性查找的思路挺傻的，何不直接找出郭靖所在的房间号，然后直接去这个房间找郭靖呢？
数据结构——哈希表
没实力的码农写的渣渣博客
08-16 122
哈希表：通过键值对的方式存储数据，通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表或哈希表；具体解释可以查看其它博文 本文使用C语言利用开放寻址线性探测法创建哈希表： #include <stdio.h> #include <stdlib.h> #define hashSize 10 //宏定义哈希表的大小 struct hashTable{ int *elem; //利用指针存
"哈希表实现电话号码查询-数据结构课程设计报告
哈希表实现电话号码查询是数据结构课程设计报告中的重要内容。该报告首先对实训的要求进行了详细描述，包括需要进行的需求分析。其次，对系统设计进行了总体设计和详细设计，包括程序头文件、学生信息类及哈希表类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值