数据结构之哈希表

已于 2024-08-01 12:50:36 修改
阅读量166 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 算法 c++
于 2022-10-21 19:53:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60529319/article/details/127452711
版权
本文详细介绍了哈希表的工作原理，特别是哈希链表的实现，包括数据结构定义、初始化、插入、删除、查找和销毁等操作。通过实例展示了如何使用哈希链表存储和操作宠物信息，强调了空间换时间的优化策略。此外，还提供了哈希数组的另一种实现方式，探讨了其内存管理和操作流程。
摘要由CSDN通过智能技术生成

文章目录

哈希表

哈希表的原理精讲

哈希表 - 散列表，它是基于快速存取的角度设计的，也是一种典型的“空间换时间”的做法

需求：实现一种算法可以根据宠物编号快速找到宠物，并且获取宠物信息

  • 先按照宠物编号给宠物有规律的分组（下方利用的是 编号%5）
  • 访问的时候，先找到组，再根据组找宠物，这样可以提高搜索效率
键(key)：宠物的编号 如， 1 、 5 、 19 。。。
值(value)：宠物的其它信息（包含性别、年龄和战斗力等）
索引(index):数组的下标(0,1,2,3,4) ，用以快速定位和检索数据
哈希桶:保存索引的数组(链表或数组)，数组成员为每一个索引值相同的多个元素
哈希函数:将宠物编号映射到索引上，采用求余法，如：组员编号 19

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5YCVWnqP-1666352735604)(D:\冲击offer\博客\数据结构\assets\clip_image002-16662691695151.jpg)]

  • 0 1 2 3 4 :从纵向看是二级指针数组保存了一级指针,每一个一级指针都是一个链表的队头
  • 即 : 二级指针保存了链表的队头

哈希链表的算法实现

哈希链表数据结构的定义

//哈希表实现
struct MyHash
{
	int key;
	void * data;
	MyHash *next;
};

struct MyHashList
{
	//索引数目
	int indexNum;
	//保存索引的队头
	//MyHash *myHashArr[];数组是不可以改变指向,所以不能接受开辟的内存
	MyHash **myHashArr;
};

哈希链表初始化

//改变一级指针保存的值,需要使用二级指针
bool initMyHashList(MyHashList * myHashList, int indexNum)
{
	if (myHashList == NULL)return false;
	myHashList->indexNum = indexNum;

	myHashList->myHashArr = new MyHash*[myHashList->indexNum];
	if (myHashList->myHashArr == NULL)return false;

	for (int i = 0; i < indexNum; i++)
	{
		int temp = i;
		myHashList->myHashArr[i] = new MyHash;

		//分配内存成功,就至0
		if (myHashList->myHashArr[i] != NULL)
		{
			memset(myHashList->myHashArr[i], 0, sizeof(MyHash));
		}
		else
		{
			//分配内存失败,释放之前所有分配的内存
			for (int j = 0; j < temp - 1; j++)
			{
				delete myHashList->myHashArr[j];
			}
			delete myHashList->myHashArr;
			return false;
		}
	}

	return true;
}

哈希函数

//获取哈希索引
int getHashIndex(int key, int indexNum)
{
	return key % indexNum;
}

哈希链表插入元素

//插入元素
void insertHashCode(MyHashList * hashList, int key, void * data)
{
	if (hashList == NULL)return;

	if (data == NULL)return;
	//创建节点并且初始化节点
	MyHash * code = new MyHash;
	if (code == NULL)return;
	code->data = data;
	code->key = key;
	code->next = NULL;

	//获取哈希索引
	int index = getHashIndex(key, hashList->indexNum);

	//插入:头插法
	MyHash * temp = hashList->myHashArr[index]->next;
	hashList->myHashArr[index]->next = code;
	code->next = temp;

	MyHash * temp2 = hashList->myHashArr[1]->next;
}

哈希链表删除元素

//删除元素
void deleteHashCode(MyHashList * hashList, int key)
{
	if (hashList == NULL)return;

	//获取哈希索引
	int index = getHashIndex(key,hashList->indexNum);

	MyHash * pre = hashList->myHashArr[index];
	MyHash * cur = pre->next;
	while (cur)
	{
		if (cur->key == key)
		{
			pre->next = cur->next;
			delete cur;
			cur = NULL;

			break;
		}
		pre = cur;
		cur = pre->next;
	}
}

哈希链表销毁

//销毁哈希链表
void destoryMyHashList(MyHashList * hashList)
{
	if (hashList == NULL)return;

	for (int i = 0; i < hashList->indexNum; i++)
	{
		MyHash * temp = hashList->myHashArr[i];
		MyHash * temp1 = temp->next;
		while (temp1 != NULL)
		{
			temp->next = temp1->next;
			delete temp1;

			temp1 = temp->next;
		}

		delete hashList->myHashArr[i];
	}
	delete[] hashList->myHashArr;
}

哈希链表查找元素

//查找元素
MyHash * searchHashCode(MyHashList * hashList, int key)
{
	if (hashList == NULL)return NULL;

	//获取哈希索引
	int index = getHashIndex(key, hashList->indexNum);

	MyHash * cur = hashList->myHashArr[index]->next;
	while (cur)
	{
		if (cur->key == key)
		{
			return cur;
			break;
		}
		cur = cur->next;
	}
}

哈希链表实现完整代码(相对常用):

#include<iostream>
using namespace std;

//哈希表实现
struct MyHash
{
	int key;
	void * data;
	MyHash *next;
};

struct MyHashList
{
	//索引数目
	int indexNum;
	//保存索引的队头
	//MyHash *myHashArr[];数组是不可以改变指向,所以不能接受开辟的内存
	MyHash **myHashArr;
};


//改变一级指针保存的值,需要使用二级指针
bool initMyHashList(MyHashList * myHashList, int indexNum)
{
	if (myHashList == NULL)return false;
	myHashList->indexNum = indexNum;

	myHashList->myHashArr = new MyHash*[myHashList->indexNum];
	if (myHashList->myHashArr == NULL)return false;

	for (int i = 0; i < indexNum; i++)
	{
		int temp = i;
		myHashList->myHashArr[i] = new MyHash;

		//分配内存成功,就至0
		if (myHashList->myHashArr[i] != NULL)
		{
			memset(myHashList->myHashArr[i], 0, sizeof(MyHash));
		}
		else
		{
			//分配内存失败,释放之前所有分配的内存
			for (int j = 0; j < temp - 1; j++)
			{
				delete myHashList->myHashArr[j];
			}
			delete myHashList->myHashArr;
			return false;
		}
	}

	return true;
}


//获取哈希索引
int getHashIndex(int key, int indexNum)
{
	return key % indexNum;
}

//插入元素
void insertHashCode(MyHashList * hashList, int key, void * data)
{
	if (hashList == NULL)return;

	if (data == NULL)return;
	//创建节点并且初始化节点
	MyHash * code = new MyHash;
	if (code == NULL)return;
	code->data = data;
	code->key = key;
	code->next = NULL;

	//获取哈希索引
	int index = getHashIndex(key, hashList->indexNum);

	//插入:头插法
	MyHash * temp = hashList->myHashArr[index]->next;
	hashList->myHashArr[index]->next = code;
	code->next = temp;

	MyHash * temp2 = hashList->myHashArr[1]->next;
}

//删除元素
void deleteHashCode(MyHashList * hashList, int key)
{
	if (hashList == NULL)return;

	//获取哈希索引
	int index = getHashIndex(key,hashList->indexNum);

	MyHash * pre = hashList->myHashArr[index];
	MyHash * cur = pre->next;
	while (cur)
	{
		if (cur->key == key)
		{
			pre->next = cur->next;
			delete cur;
			cur = NULL;

			break;
		}
		pre = cur;
		cur = pre->next;
	}
}

//查找元素
MyHash * searchHashCode(MyHashList * hashList, int key)
{
	if (hashList == NULL)return NULL;

	//获取哈希索引
	int index = getHashIndex(key, hashList->indexNum);

	MyHash * cur = hashList->myHashArr[index]->next;
	while (cur)
	{
		if (cur->key == key)
		{
			return cur;
			break;
		}
		cur = cur->next;
	}
}

//遍历元素
void printHashList(MyHashList *hashList)
{
	if (hashList == NULL)return;

	for (int i = 0; i < hashList->indexNum; i++)
	{
		MyHash * temp = hashList->myHashArr[i]->next;
		cout << "key % hashList.indexNum = " << i  << endl;
		while (temp != NULL)
		{
			cout << "key = " << temp->key << "  " << "data = " << *((char*)(temp->data)) << endl;
			temp = temp->next;
		}
		cout << endl;
	}
}

//销毁哈希链表
void destoryMyHashList(MyHashList * hashList)
{
	if (hashList == NULL)return;

	for (int i = 0; i < hashList->indexNum; i++)
	{
		MyHash * temp = hashList->myHashArr[i];
		MyHash * temp1 = temp->next;
		while (temp1 != NULL)
		{
			temp->next = temp1->next;
			delete temp1;

			temp1 = temp->next;
		}

		delete hashList->myHashArr[i];
	}
	delete hashList->myHashArr;
}

int main()
{
	//初始化
	MyHashList * hashList = new MyHashList;
	initMyHashList(hashList, 5);

	char arr[25];
	for (int i = 0; i < 25; i++)
	{
		arr[i] = (i + 'A');
	}
	//插入元素
	for (int i = 0; i < 25; i++)
	{
		insertHashCode(hashList, i + 1, &arr[i]);
	}

	//删除元素
	deleteHashCode(hashList, 10);

	//查找元素
	MyHash * myHashCode = searchHashCode(hashList, 25);
	cout << "key = 25   " << "data = " << *((char*)myHashCode->data) << endl << endl;

	//打印元素
	printHashList(hashList);

	//销毁
	destoryMyHashList(hashList);

	delete hashList;
	hashList = NULL;

	system("pause");
	return 0;
}

哈希数组实现完整代码:

  • 这里使用了三级指针，第一次使用，确实刺激
#include<iostream>
using namespace std;

//哈希表实现
struct MyHash
{
	int key;
	void * data;
};
struct MyHashArr
{
	MyHash ** *hashArr;//这是一个保存*hashArr类型的二维数组
	int *arr;//用于记录每一个桶所保存的元素

	int size;
	int IndexNum;
};

//初始化
void initMyHashArr(MyHashArr * myHashArr, int size, int indexNum)
{
	if (myHashArr == NULL || size < 0 || indexNum < 0)return;
	myHashArr->size = size;
	myHashArr->IndexNum = indexNum;

	myHashArr->hashArr = new MyHash**[indexNum];
	myHashArr->arr = new int[indexNum];
	memset(myHashArr->arr, 0, sizeof(int)*indexNum);

	for (int i = 0; i < indexNum; i++)
	{
		int temp = i;
		myHashArr->hashArr[i] = new MyHash*[size];

		//分配内存成功,就至0
		if (myHashArr->hashArr[i] != NULL)
		{
			memset(myHashArr->hashArr[i], 0, sizeof(MyHash));
		}
		else
		{
			//分配内存失败,释放之前所有分配的内存
			for (int j = 0; j < temp - 1; j++)
			{
				delete myHashArr->hashArr[j];
			}
			delete myHashArr->hashArr;
			delete myHashArr->arr;
			return;
		}
	}
}
//获取哈希索引
int getHashIndex(MyHashArr * myHashArr, int key)
{
	if (myHashArr == NULL || key < 0)return 0;
	return key % myHashArr->IndexNum;
}

//插入元素
void insertHashIndex(MyHashArr * myHashArr, int key, void * data)
{
	if (myHashArr == NULL || key < 0 || data == NULL)return;


	//创建结构体
	MyHash * code = new MyHash;
	if (code == NULL)return;
	code->data = data;
	code->key = key;

	int index = getHashIndex(myHashArr, key);
	//判断索引为index的数组有没有满,如果满了直接退出
	if (myHashArr->size == myHashArr->arr[index])return;

	myHashArr->hashArr[index][myHashArr->arr[index]] = code;
	myHashArr->arr[index]++;
}

//打印哈希
void printHashArr(MyHashArr * myHashArr)
{
	if (myHashArr == NULL)return;

	for (int i = 0; i < myHashArr->IndexNum; i++)
	{
		cout << "------------------" << i  << "--------------------" << endl;
		for (int j = 0; j < myHashArr->arr[i]; j++)
		{
			cout << "key = " << myHashArr->hashArr[i][j]->key << "  data=" << *((char *)(myHashArr->hashArr[i][j]->data)) << endl;
		}
	}
}

//删除元素
void deleteHashCode(MyHashArr * myHashArr, int key)
{
	if (myHashArr == NULL || key < 0)return;
	int index = getHashIndex(myHashArr, key);

	for (int i = 0; i < myHashArr->arr[index]; i++)
	{
		int temp = i;
		if (myHashArr->hashArr[index][i]->key == key)
		{
			for (int j = i + 1; j < myHashArr->arr[index]; j++)
			{
				myHashArr->hashArr[index][j - 1] = myHashArr->hashArr[index][j];
			}
			myHashArr->arr[index]--;
			return;
		}
	}

	return;
}

//搜索元素
MyHash * findHashIndex(MyHashArr * myHashArr, int key)
{
	if (myHashArr == NULL || key < 0)return NULL;
	int index = getHashIndex(myHashArr, key);

	for (int i = 0; i < myHashArr->arr[index]; i++)
	{
		int temp = i;
		if (myHashArr->hashArr[index][i]->key == key)
		{
			return myHashArr->hashArr[index][i];
		}
	}
	return NULL;
}

//销毁哈希
void destoryHashIndex(MyHashArr * myHashArr)
{
	if (myHashArr == NULL)return;


	for (int i = 0; i < myHashArr->IndexNum; i++)
	{
		delete[] myHashArr->hashArr[i];
		myHashArr->hashArr[i] = NULL;
	}
	delete[] myHashArr->arr;
	delete[] myHashArr->hashArr;
	myHashArr->arr = NULL;
	myHashArr->hashArr = NULL;
}

int main()
{
	MyHashArr * myHashArr = new MyHashArr;
	initMyHashArr(myHashArr,5,5);

	char arr[25];
	for (int i = 0; i < 19; i++)
	{
		arr[i] = ('A' + i);
		insertHashIndex(myHashArr, i + 1, &arr[i]);
	}

	//删除元素
	deleteHashCode(myHashArr, 16);

	//查找元素
	MyHash * code = findHashIndex(myHashArr, 7);
	cout << "key = " << code ->key << "  data=" << *((char *)(code->data)) << endl;

	printHashArr(myHashArr);

	//销毁
	destoryHashIndex(myHashArr);
	delete myHashArr;

	system("pause");
	return 0;
}

在这里插入图片描述

小瑞的学习笔记
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
哈希表基础
wangzai32100的博客
07-26 545
总结一下，当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。但是哈希法也是牺牲了空间换取了时间，因为我们要使用额外的数组，set或者是map来存放数据，才能实现快速的查找。如果在做题目的时候遇到需要判断一个元素是否出现过的场景也应该第一时间想到哈希法！httpshttpshttpshttpshttpshttpshttpshttps。......
5哈希表-set/数组
sueong的博客
03-31 1076
在C++中，set 和 map 分别提供以下三种数据结构，其底层实现以及优劣如下表所示 参考：https://programmercarl.com/%E5%93%88%E5%B8%8C%E8%A1%A8%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html#%E5%93%88%E5%B8%8C%E5%87%BD%E6%95%B0 242. 有效的字母异位词 给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。 注意：若 s 和 t 中每个字符出现的次数
C++ STL中哈希表 hash_map从头到尾详细介绍
热门推荐
susandebug
06-26 7万+
0 为什么需要hash_map 用过map吧？map提供一个很常用的功能，那就是提供key-value的存储和查找功能。例如，我要记录一个人名和相应的存储，而且随时增加，要快速查找和修改： 岳不群－华山派掌门人，人称君子剑 张三丰－武当掌门人，太极拳创始人 东方不败－第一高手，葵花宝典 ... 这些信息如果保存下来并不复杂，但是找起来比较麻烦。例如我要找"张三丰"的信
算法笔记算法初步（4.2散列）
cimixian的博客
04-30 270
一、使用散列思想的查询 1.给出N个整数，在给出M个数，问这M个数中的每个数是否在N个数中出现过 思路： 设定布尔型的数组 #include<stdio.h> const int maxn = 100010; bool hashArr[maxn] = {false};//用空间交换时间，而非对每个待查询的数遍历所有的数 //所谓hash是形成一个线性表,时间复杂度O(m+n...
【C++】哈希表基础知识
lemonxiaoxiao的博客
06-15 1302
首先什么是 哈希表，哈希表（英文名字为Hash table，国内也有一些算法书籍翻译为散列表）是根据关键码的值而直接进行访问的数据结构。直白来讲其实数组就是一张哈希表。哈希表中关键码就是数组的索引下标，然后通过下标直接访问数组中的元素，如下图所示： 那么哈希表能解决什么问题呢？一般哈希表都是用来快速判断一个元素是否出现集合里。例如：要查询一个名字是否在这所学校里。要枚举的话时间复杂度是O(n)，但如果使用哈希表的话， 只需要O(1)就可以做到。 我们只需要初始化时把这所学校里学生的名字都存在哈希表里，在查
数据结构之哈希表.pdf
09-30
在这个“数据结构之哈希表”的实验中，主要目标是设计并实现一个基于哈希表的电话号码查询系统。以下是实验中涉及的主要知识点： 1. **哈希函数**：哈希函数是哈希表的核心，它负责将键转换为数组索引。在实验中，...
数据结构 C语言 哈希表.docx
03-28
### 数据结构：C语言实现哈希表 #### 核心知识点概述 本篇文章将围绕一个C语言中的哈希表实现案例展开，详细解析哈希表的基本概念、设计思路及其实现过程。通过阅读本文，您将了解到哈希表在C语言编程中的应用，并...
数据结构试验哈希表优质资料.doc
12-02
数据结构试验哈希表优质资料 本资源是一个关于数据结构试验哈希表优质资料的文档，主要包括考试日程安排、考试成绩统计和排序、查找学生成绩等功能。下面是该资源的详细知识点： 一、考试日程安排 * 问题描述：...
哈希表数据结构ADT实现代码
12-02
哈希表（Hash Table）是一种高效的数据结构，用于存储和检索键值对。它通过将键（Key）映射到数组的索引位置来实现快速访问。哈希表的实现通常涉及两个主要部分：哈希函数和冲突解决策略。在这个项目中，我们将深入...
数据结构实验五哈希表设计c语言
04-25
哈希表是一种常用的数据结构，它可以快速地存储和检索数据。在本实验中，我们设计了一种哈希表，以学生姓名为关键字，存储学生信息，并实现了查找学生信息的功能。 哈希表的构造方法 在本实验中，我们使用了链地址...
哈希算法和哈希表
qq_41757528的博客
09-16 1867
这篇文章将会简单介绍几种常见的哈希算法，然后是C++或Java的标准库中哈希函数与哈希表的基本使用，最后将会提供一个使用C语言手搓FNV-1a算法的示例，以及使用它实现的哈希表。这篇文章虽然内容不多，但前前后后，也是删删改改了好多天了，虽然内容还是不尽人意，但希望此文能为你提供一点帮助，不说理解哈希，至少能够使用吧。不知道某位大佬会不会来看这篇文章，关于哈希表的部分我不是很拿得准，如果理解有误，请帮我指出。
c++，哈希表，创建与查找
zxy_550的博客
11-21 2277
哈希表详解，c++ #include #include&amp;lt;string.h&amp;gt; using namespace::std; #define Max_capacity 50 #define SUCCESS 1 #define UNSCESS 0 #define random_six “-1234” class Hashtable{ public...
STL之(哈希表）hashtable
jyh的博客
08-12 5482
容器hashtable(哈希表）：另外一种底层机制 其基本原理是：使用一个下标范围比较大的数组来存储元素。把关键字Key通过一个固定的算法函数即所谓的哈希函数（散列函数）转换成一个整型数字，然后就将该数字对数组长度进行取余，取余结果就当作数组的下标，将value存储在以该数字为下标的list空间里。也可以简单的理解为，按照关键字key为每一个元素“分类”，然后将这个元素存储在相应“类”所对应的地...
详细解说STL hash_map系列
fisher_jiang的专栏
04-01 2900
0 为什么需要hash_map 用过map吧？map提供一个很常用的功能，那就是提供key-value的存储和查找功能。例如，我要记录一个人名和相应的存储，而且随时增加，要快速查找和修改： 岳不群－华山派掌门人，人称君子剑张三丰－武当掌门人，太极拳创始人东方不败－第一高手，葵花宝典...这些信息如果保存下来并不复杂，但是找起来比较麻烦。例如我要找"张三丰"的信息，最傻的方法就是取得所有的记录，然后
三、哈希表（1）：哈希表基础理论
努力努力努力
09-04 4495
首先什么是 哈希表 ？哈希表（英文名字为Hash table，国内也有一些算法书籍翻译为散列表，大家看到这两个名称知道都是指hash table就可以了）。 哈希表是根据关键码的值而直接进行访问的数据结构。 这么这官方的解释可能有点懵，其实直白来讲其实数组就是一张哈希表。哈希表中关键码就是数组的索引下表，然后通过下表直接访问数组中的元素，如下图所示： 那么哈希表能解决什么问题呢？一般哈希表都是用来快速判断一个元素是否出现集合里。 例如要查询一个名字是否在这所学校里。要枚举的话时间复杂度是..
关于哈希表一种数据结构---std::unordered_set
weixin_43700493的博客
04-08 2929
输入：nums1 = [1,2,2,1], nums2 = [2,2] 输出：[2] unordered_set成员方法.find(key) unordered_set.find(key) 查找值为key的元素，如果找到，就返回指向该元素的正向迭代器；反之，则返回尾后迭代器(结束迭代器)。 unordered_set.end() 直接返回尾后迭代器。即返回指向容器最后一个数据单元+1的指针。 unordered_set<int> result_set; 定义哈希表存放结果 unordere
图解大顶堆的构建、排序过程
最新发布
sagima_sdu的博客
08-12 504
开始，
【长度最小的子数组】python刷题记录
m0_73629042的博客
08-12 240
【代码】【长度最小的子数组】python刷题记录。
哈希表详解与数据结构基础
"什么是哈希表-数据结构ppt课件" 哈希表，也称为散列表，是一种高效的数据结构，主要用于快速查找和存储数据。在哈希表中，数据的存储位置是通过一个特定的函数——哈希函数计算得出的，这个函数能够将关键字（key...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值