数据结构-哈希表（java实现）

最新推荐文章于 2024-05-12 09:24:57 发布
最新推荐文章于 2024-05-12 09:24:57 发布
阅读量2.5k 收藏 16
点赞数 5
分类专栏： 数据结构与算法 java 文章标签： 链表 数据结构 java 算法
原文链接：https://blog.csdn.net/weixin_44279178/article/details/108469778
版权

文章目录

1、哈希表介绍

散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。（哈希表本质上就是个数组，哈希表的底层是数组）
实现哈希表的两种方法：
1、数组+链表
2、数组+红黑二叉树

推荐对话简图理解概念一文彻底搞定哈希表！
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

2、哈希函数H（k）

哈希函数：建立起数据元素的存放位置与数据元素的关键字之间的对应关系的函数。即使用哈希函数可将被查找的键转换为数组的索引。理想情况下它应该运算简单并且保证任何两个不同的关键字映射到不同的单元（索引值）。但是，这是不可能的，很多时候我们都需要处理多个键被哈希到同一个索引值的情况，即哈希碰撞冲突
在这里插入图片描述

哈希函数的构造方法：

构造哈希函数的目标：使得到的哈希地址尽可能均匀地分布在m个连续内存单元地址上，同时使计算过程尽可能简单以达到尽可能高的时间效率。
根据关键字的结构和分布的不同，有多种构造哈希函数的方法。

（1）直接定址法

取关键字或关键字的某个线性函数值为哈希地址。即H(key)=key 或 H(key)=a*key+b (a,b为常数)。
举例1：统计1-100岁的人口，其中年龄作为关键字，哈希函数取关键字自身。查找年龄25岁的人口有多少，则直接查表中第25项。
在这里插入图片描述
举例2：统计解放以后出生人口，其中年份作为关键字，哈希函数取关键字自身加一个常数H(key)=key+(-1948).查找1970年出生的人数，则直接查(1970-1948)=22项即可

在这里插入图片描述

（2）数字分析法

若关键字是以r为基的数（如：以10为基的十进制数），并且哈希表中可能出现的关键字都是事先知道的，则可取关键字的若干数位组成哈希地址。
举例：有80个记录，其关键字为8位十进制数，假设哈希表长1000，则可取两位十进制数组成哈希地址，为了尽量避免冲突，可先分析关键字。
在这里插入图片描述

经分析，发现第一位、第二位都是8,1，第三位只可能取3或4，第八位只可能取2,5或7，所以这四位不可取，那么对于第四、五、六、七位可看成是随机的，因此，可取其中任意两位，或取其中两位与另外两位的叠加求和舍去进位作为哈希地址。

（3）平方取中法

取关键字平方后的中间几位为哈希地址。（较常用的一种）

举例：为BASIC源程序中的标识符键一个哈希表（假设BASIC语言允许的标识符为一个字母或者一个字母和一个数字两种情况，在计算机内可用两位八进制数表示字母和数字），假设表长为512=2^{9}，则可取关键字平方后的中间9位二进制数为哈希地址。（每3个二进制位可表示1位八进制位，即3个八进制位为9个二进制位）
A ：01 （A的ASCII码值为65,65的八进制为101，取后两位表示关键字）
B：02 （B的ASCII码值为66,66的八进制为102，取后两位表示关键字）
…
Z：32（Z的ASCII码值为90,90的八进制为132，取后两位表示关键字）
…
0：60（0的ASCII码值为48,48的八进制为60，取后两位表示关键字）
…
9：71（9的ASCII码值为57,57的八进制为71，取后两位表示关键字）
在这里插入图片描述

（4）折叠法

将关键字分割成位数相同的几部分（最后一部分的位数可不同），然后取这几部分的叠加和（舍去进位）作为哈希地址。适用于关键字位数比较多，且关键字中每一位上数字分布大致均匀时。
举例：根据国际标准图书编号（ISBN）建立一个哈希表。如一个国际标准图书编号 0-442-20586-4的哈希地址为：
在这里插入图片描述

（5）除留余数法

取关键字被某个不大于哈希表表长m的数p除后所得余数为哈希地址（p为素数）
H（key）=key MOD p，p<=m （最简单，最常用）p的选取很重要
一般情况，p可以选取为质数或者不包含小于20的质因数的合数（合数指自然数中除了能被1和本身整除外，还能被其他数（0除外）整除的数）。
在这里插入图片描述

（6）随机数法

选择一个随机函数，取关键字的随机函数值为它的哈希地址。即H（key）=random（key），其中random为随机函数。适用于关键字长度不等时。
总结：实际工作中根据情况不同选用的哈希函数不同，通常，考虑因素如下：
（1）计算哈希函数所需时间（包括硬件指令的因素）
（2）关键字的长度
（3）哈希表的大小
（4）关键字的分布情况
（5）记录的查找频率

3、解决哈希碰撞

在哈希表中，虽然冲突很难避免，但发生冲突的可能性却有大有小。这主要与三个因素有关：

  • 与装填因子有关。所谓装填因子α是指哈希表中已存入的元素数n与哈希地址空间大小m的比值，即α=n/m。α越小，冲突的可能性就越小；但α越小，存储空间的利用率就越低。
  • 与所采用的哈希函数有关。
  • 与解决冲突的哈希冲突函数有关。

1、开放地址法

开放地址法：通过系统的方法找到系统的空位（三种：线性探测、二次探测、再哈希法），并将待插入的元素填入，而不再使用用hash函数得到数字作为数组的下标。

即简单理解：发生冲突时查找周围一个空位置存放记录。设置一个查找周围一个空位置的函数。

  • 线性探测：假若当前要插入的位置已经被占用了之后，沿数组下标递增方向查找，直到找到空位为止
    在这里插入图片描述
    在这里插入图片描述
  • 二次探测：二次探测和线性探测的区别在于二次探测的步长是，若计算的原始下标是x则二次探测的过程是x+12，x+22，x+32，x+42，x+52随着探测次数的增加，探测的步长是探测次数的二次方（因此名为平方探测法）。二次探测会产生二次聚集：即当插入的几个数经过hash后的下标相同的话，那么这一串数字插入的探测步长会增加很快
    在这里插入图片描述

平方探测法可以避免出现堆积问题。
缺点是不能探测到哈希表上的所有单元，但至少能探测到一半单元。

  • 再hash法：为了消除原始聚集和二次聚集，把关键字用不同的hash函数再做一遍hash化，用过这个结果作为探测的步长，这样对于特定的关键字在整个探测中步长不变，但是不同的关键字会使用不同的步长。stepSize = constant - （key % constant） 这个hash函数求步长比较实用，constant是小于数组容量的质数。（注意：第二个hash函数必须和第一个hash函数不同，步长hash函数输出的结果值不能为0）

哈希表的扩容：
关于开放寻址，如果一直找不到空的位置怎么办？
这种情况不存在，为啥嘞？你这样想，是因为你考虑了一个前提，那就是位置已经被占光了，没有空位置了，但是实际情况是位置不会被占光的，因为有一定量的位置被占了的时候就会发生扩容。当哈希表被占的位置比较多的时候，出现哈希冲突的概率也就变高了，所以很有必要进行扩容。
那么这个扩容是怎么扩的呢？
这里一般会有一个增长因子的概念，也叫作负载因子，简单点说就是已经被占的位置与总位置的一个百分比，比如一共十个位置，现在已经占了七个位置，就触发了扩容机制，因为它的增长因子是0.7，也就是达到了总位置的百分之七十就需要扩容。拿HashMap来说，当它当前的容量占总容量的百分之七十五的时候就需要扩容了。而且这个扩容也不是简单的把数组扩大，而是新创建一个数组是原来的2倍，然后把原数组的所有元素都重新Hash一遍放到新的数组。

2、链地址法（拉链法）

链地址法 ：创建一个存放单词链表的数组，数组内不直接存放元素，而是存储元素的链表。发生冲突的时候，数据项直接接到这个数组下标所指的链表中即可。
　　优势：填入过程允许重复，所有关键值相同的项放在同一链表中，找到所有项就需要查找整个是链表，稍微有点影响性能。删除只需要找到正确的链表，从链表中删除对应的数据即可。表容量是质数的要求不像在二次探测和再hash法中那么重要，由于没有探测的操作，所以无需担心容量被步长整除，从而陷入无限循环中。

如果冲突的很多，那这个增加的链表岂不是很长？
如果冲突过多的话，这个key对应的链表会变得比较长，怎么处理呢？这里举个例子吧，拿java集合类中的HashMap来说吧，如果这里的链表长度大于等于8的话，链表就会转换成红黑树结构，当然如果长度小于等于6的话，就会还原链表。以此来解决链表过长导致的性能问题。这样设计是因为中间有个7作为一个差值，来避免频繁的进行树和链表的转换，因为转换频繁也是影响性能的啊。
在这里插入图片描述

4、实例：使用哈希表管理雇员信息

题目：有一个公司,当有新的员工来报道时,要求将该员工的信息加入(id、姓名，性别，电话),当输入该员工的id时,要求查找到该员工的所有信息.
要求：

  • 不使用数据库,速度越快越好
  • 添加时，保证按照id从低到高插入
  • 使用链表来实现哈希表, 该链表不带表头

思路分析：
添加雇员信息
1,创建一个节点类存储雇员的信息（id，name，sex，phone）
2,创建一个定长数组为哈希表，哈希表的每个数组元素储存一条链表头节点
3,根据散列函数将要添加的雇员id进行散列（比如：散列函数构造采用简单的4,取模法：H(k)=id % size 假如id=1001 数组长度为7则取余后的key为0 对应的数组下标为0）
5,根据id散列后的key值将对应id的雇员节点链接到对应的数组下标下的链表后面

查找对应id的雇员信息：
1,根据id散列得到key值
2,到key值对应的数组下标的链表中进行查询
在这里插入图片描述

import java.util.Scanner;
public class HashTabDemo {
	public static void main(String[] args) {		
		//创建哈希表
		HashTab hashTab = new HashTab(7);	
		//写一个简单的菜单
		int n;
		Scanner scanner = new Scanner(System.in);
		while(true) {
			System.out.println("1:  添加雇员");
			System.out.println("2: 显示雇员");
			System.out.println("3: 查找雇员");
			System.out.println("4: 退出系统");			
			n = scanner.nextInt();
			switch (n) {
			case 1:
				System.out.println("输入id");
				int id = scanner.nextInt();
				System.out.println("输入名字");
				String name = scanner.next();
				System.out.println("输入性别");
				String sex = scanner.next();
				System.out.println("输入电话");
				String phone = scanner.next();
				//创建 雇员
				Emp emp = new Emp(id, name,sex,phone);
				hashTab.add(emp);
				break;
			case 2:
				hashTab.list();
				break;
			case 3:
				System.out.println("请输入要查找的id");
				id = scanner.nextInt();
				hashTab.findEmpById(id);
				break;
			case 4:
				scanner.close();
				System.exit(0);
			default:
				break;
			}
		}	
	}
}
//创建HashTab 管理多条链表
class HashTab {
	private EmpLinkedList[] empLinkedListArray;
	private int size; //表示有多少条链表	
	//构造器
	public HashTab(int size) {
		this.size = size;
		//初始化empLinkedListArray
		empLinkedListArray = new EmpLinkedList[size];
		for(int i = 0; i < size; i++) {
			empLinkedListArray[i] = new EmpLinkedList();
		}
	}
	
	//添加雇员
	public void add(Emp emp) {
		//根据员工的id ,得到该员工应当添加到哪条链表
		int empLinkedListNO = hashFun(emp.id);
		//将emp 添加到对应的链表中
		empLinkedListArray[empLinkedListNO].add(emp);
		
	}
	//遍历所有的链表,遍历hashtab
	public void list() {
		for(int i = 0; i < size; i++) {
			empLinkedListArray[i].list(i);
		}
	}
	
	//根据输入的id,查找雇员
	public void findEmpById(int id) {
		//使用散列函数确定到哪条链表查找
		int empLinkedListNO = hashFun(id);
		Emp emp = empLinkedListArray[empLinkedListNO].findEmpById(id);
		if(emp != null) {//找到
			System.out.printf("在第%d条链表中找到 雇员 id = %d name = %s sex = %s phone = %s", (empLinkedListNO + 1), id,emp.name,emp.sex,emp.phone);
		}else{
			System.out.println("在哈希表中，没有找到该雇员~");
		}
	}
	
	//编写散列函数, 使用一个简单取模法
	public int hashFun(int id) {
		return id % size;
	}
	
	
}

//表示一个雇员
class Emp {
	public int id;
	public String name;
	public String sex;
	public String phone;
	public Emp next; //next 默认为 null
	public Emp(int id, String name,String sex,String phone) {
		super();
		this.id = id;
		this.name = name;
		this.sex = sex;
		this.phone = phone;
	}
}

//创建EmpLinkedList ,表示链表
class EmpLinkedList {
	
	//头指针，指向第一个Emp,因此我们这个链表的head 是直接指向第一个Emp
	private Emp head; //默认null	
	
	//添加雇员到链表
	//说明
	//1. 假定，当添加雇员时，id 是自增长，即id的分配总是从小到大
	//   因此我们将该雇员直接加入到本链表的最后即可
	public void add(Emp emp) {
		//如果是添加第一个雇员
		if(head == null) {
			head = emp;
			return;
		}
		//如果不是第一个雇员，则使用一个辅助的指针，帮助定位到最后
		Emp curEmp = head;
		while(true) 
		{
			if(curEmp.next == null) {//说明到链表最后
				break;
			}
			curEmp = curEmp.next; //后移
		}
		//退出时直接将emp 加入链表
		curEmp.next = emp;
	}
	
	//遍历链表的雇员信息
	public void list(int no) {
		if(head == null) { //说明链表为空
			System.out.println("第 "+(no+1)+" 链表为空");
			return;
		}
		System.out.print("第 "+(no+1)+" 链表的信息为");
		Emp curEmp = head; //辅助指针
		while(true) {
			System.out.printf(" => id=%d name=%s sex=%s phone=%s\t", curEmp.id, curEmp.name,curEmp.sex,curEmp.phone);
			if(curEmp.next == null) {//说明curEmp已经是最后结点
				break;
			}
			curEmp = curEmp.next; //后移，遍历
		}
		System.out.println();
	}
	
	//根据id查找雇员
	//如果查找到，就返回Emp, 如果没有找到，就返回null
	public Emp findEmpById(int id) {
		//判断链表是否为空
		if(head == null) {
			System.out.println("链表为空");
			return null;
		}
		//辅助指针
		Emp curEmp = head;
		while(true) {
			if(curEmp.id == id) {//找到
				break;//这时curEmp就指向要查找的雇员
			}
			//退出
			if(curEmp.next == null) {//说明遍历当前链表没有找到该雇员
				curEmp = null;
				break;
			}
			curEmp = curEmp.next;//以后
		}
		
		return curEmp;
	}
	
}

测试输出

1: 添加雇员
2: 显示雇员
3: 查找雇员
4: 退出系统
1
输入id
1001
输入名字
张三
输入性别
男
输入电话
12345674512
1: 添加雇员
2: 显示雇员
3: 查找雇员
4: 退出系统
1
输入id
1002
输入名字
李强
输入性别
男
输入电话
14578214573
1: 添加雇员
2: 显示雇员
3: 查找雇员
4: 退出系统
1
输入id
1009
输入名字
王文
输入性别
女
输入电话
14789654233
1: 添加雇员
2: 显示雇员
3: 查找雇员
4: 退出系统
2
第 1 链表的信息为 => id=1001 name=张三 sex=男 phone=12345674512
第 2 链表的信息为 => id=1002 name=李强 sex=男 phone=14578214573 => id=1009 name=王文 sex=女 phone=14789654233
第 3 链表为空
第 4 链表为空
第 5 链表为空
第 6 链表为空
第 7 链表为空
1: 添加雇员
2: 显示雇员
3: 查找雇员
4: 退出系统
3
请输入要查找的id
1009
在第2条链表中找到 雇员 id = 1009 name = 王文 sex = 女 phone = 14789654233
1: 添加雇员
2: 显示雇员
3: 查找雇员
4: 退出系统

本文转自数据结构（Java实现）-详谈哈希表(Hash Table)
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

备注:有添加个人积累笔记及看法。 部分截图来自：数据结构教程（Java语言描述)课件第9章 查找（4）PPT有想要PPT的可以私信我。（PPT里还有拓展例题：哈希表查找及性能分析。我现在还没看明白就没写）
不想想了
关注
  • 5
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之哈希表的java实现
三分地
03-06 5636
哈希表是一种数据结构，提供快速的插入和查找功能。哈希表基于数组存储数据，因此能在O(1)时间内定位数据。关键字值通过哈希函数映射为数组下标。缺点就是数组创建后容量固定，如果数据较多需要不断扩展其长度。 如何将关键字转换为数组下标？这个操作是通过哈希函数完成的。比如,下面就是一个简单的哈希函数， int hash(int key){ return key % array.length;//通过
Java实现数据结构---哈希表
coding is an art
10-24 291
1. 哈希表（Hash Table）也称为散列表，是一种根据关键字值（key - value）而直接访问的数据结构。它的底层是基于数组实现，通过对键值对的key进行Hash求值（哈希化）算出对应的数组下标索引，因此不需要遍历整个底层数组，插入删除效率均很快，被广泛应用。
Java Hashtable详细介绍
热门推荐
忘尘的博客
03-22 1万+
目录第1部分 Hashtable介绍第2部分 Hashtable数据结构第3部分 Hashtable源码解析(基于JDK1.6.0_45)第3.1部分 Hashtable的“拉链法”相关内容3.1.1 Hashtable数据存储数组3.1.2 数据节点Entry的数据结构第3.2部分 Hashtable的构造函数第3.3部分 Hashtable的主要对外接口3.3.1 clear()3.3.2 c...
Java 【数据结构】 哈希（Hash超详解）HashSet&HashMap【神装】
最新发布
2302_79806056的博客
05-12 5242
哈希桶机制通过将冲突的元素组织在一起，而非直接覆盖，保证了哈希表的灵活性和高效性。它允许哈希表在面对大量数据时仍能保持较好的性能，尤其是在冲突较多的情况下。通过调整哈希函数、负载因子和适时的扩容，可以进一步优化哈希表的效率。在Java中，HashMap和HashSet就是使用哈希桶来实现的，它们是Java集合框架中非常重要的组件。Java中的HashSet是一个实现了Set接口的集合类，它提供了一种存储不可重复元素的高效数据结构。
Java哈希表
weixin_56433857的博客
06-26 2101
是一种有效的存储方式，是不与其他元素进行比较，一次存取便能得到所需要的记录①Map：是映射、地图的意思，在Java中Map表示一种把K映射到V的数据类型；②HashMap：Java中用哈希数据结构实现的Map①灵活哈希函数是一个映像，因此哈希函数的设定很灵活，只要使得任何关键字由此所得的哈希函数值都落在表长允许的范围之内即可。②冲突对不同的关键字可能得到同一哈希地址，这种现象称为冲突（collision）；冲突只能尽量地少，而不能完全避免。因为，哈希函数是从关键字集合到地址集合的映像。
JAVA--哈希表
m0_56161893的博客
03-14 8068
哈希表是一种以键值key存储数据value的结构，以key作为标识值存储value值；只要输入待查找的key，即可获取其对应的value值 思路很简单，所有的key的hashcode值都是整数，那么就可以使用一个简单的数组来实现：将key作为索引，存储的数据就是value，这样就可以达到通过key快速访问任意value值的目的哈希表提供了一组key-value键值对的存取操作，其中存储的每个数据对象都有一个相应的key，键key决定了值value存储的位置 引入的问题 键必须唯一，不允许重复，每个ke
JAVA数据结构之哈希表
砥砺前行的博客
04-11 1741
●散列表（Hash table， 也叫哈希表） ，是根据关键码值(Key value)而直接进行访问的数据结构。●它通过把关键码值映射到表中一个位置来访问记录， 以加快查找的速度。这个映射函数叫做散列函数， 存放记录的数组叫做散列表。●哈希表的核心：private EmpLinkedList[] empLinkedListArray;●哈希表编程思路：先根据对象的信息将其散列，得到 hashCode根据对象的 hashCode 值，找到对应的数组下标，其实就是找到存储对象的链表。
java中的Hashtable概念和基础用法
qq_41024101的博客
09-06 3368
Hashtable [1]参考资料：JDK1.8 api文档、Hashtable源代码、百度百科 [2]概念：Hashtable(哈希表) 也可以叫做散列表，是根据关键码值(Key value)而直接进行访问的数据结构，通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。 上面这个概念可以通过代码来理解 Hashtable <key , value> 前面是key(代表键)，后面是value(代表值) public static void main(Stri...
java-leetcode面试题解哈希表第170题数据结构设计-题解.zip
03-26
哈希表是一种以键值对形式存储数据的数据结构，它通过计算键的哈希值来确定元素在数组中的位置，从而实现快速访问。哈希表的关键在于哈希函数的设计，它应尽可能使得不同的键映射到不同的数组位置，以减少冲突。常见...
基础算法与数据结构 -- Java 实现.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
最快的排序算法 javahash实现-Java-哈希算法-最快的实现，排序算法数据结构
04-07
8. 数据结构的选择：在选择数据结构时，需要考虑到ハシ表、树形结构、图结构等不同的数据结构的优缺点，并选择合适的数据结构来实现哈希算法。 9. 安全性问题：在实现哈希算法时，需要考虑到安全性问题，例如选择...
哈希表-使用Java开发的哈希表-HashTable.zip
03-04
哈希表是一种高效的数据结构，它通过特定的算法（哈希函数）将数据映射到一个固定大小的数组中，从而实现快速的插入、查找和删除操作。在Java中，`HashTable`是早期版本（Java 1.0）提供的一种线程安全的哈希表实现...
VisualHashTable:Java - 哈希表冲突可视化
07-04
哈希表冲突可视化 该项目是作为 2013 年秋季数据结构课程的项目创建的。该项目使用线性探测来处理冲突，将随机数的插入和冲突可视化到哈希表中。 您可以在下载与此项目关联的 JAR 文件，也可以自己编译该项目。 该...
JAVA学习-hash算法
qq_48772498的博客
01-13 3179
Hash 　　Hash，一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入，通过散列算法，变换成固定长度的输出，该输出就是散列值。根据散列值作为地址存放数据，这种转换是一种压缩映射，简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。查找关键字数据（如K）的时候，若结构中存在和关键字相等的记录，则必定在f(K)的存储位置上。由此，不需比较便可直接取得所查记录。我们称这个对应关系f为散列函数(Hash function)，按这个事件建立的表为散列表。 　　综上所述，根据散列
Java 集合深入理解 （十四） ：Hashtable实现原理研究
踩踩踩从踩的博客
06-05 2295
Java 集合深入理解 （十一） ：HashMap之实现原理及hash碰撞 前言 之前分析的hashmap的实现原理确实在jdk的1.8后经过Doug Lea 大牛的优化，非常适合我们学习优秀算法，以及理解其中的思想； 我们继续看一下hashtable，虽然hashtable jdk已经不推荐使用，但是我们看源码，看出早期java实现哈希表的基本思想；包括 实现线程安全的方式，及解决hash碰撞，早期扩容方式，不允许数据为空 实现原理 HashTable类中，保存实际数据的，是Entry对象
数据结构（Java实现）-详谈哈希表(Hash Table)
jQueryZK的博客
09-08 5283
1、哈希表介绍 散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 （哈希表的底层是数组） 实现哈希表的两种方法： 1、数组+链表 2、数组+红黑二叉树 2、哈希函数H（k） 哈希函数：建立起数据元素的存放位置与数据元素的关键字之间的对应关系的函数。即使用哈希函数可将被查找的键转换为数组的索引。理想情况下它应该运算简单并且保证任
哈希表（Java实现）
WYSCODER的博客
02-04 7404
哈希表（Java实现）
java基础之Hash详解
qq_38130094的博客
02-05 2936
1.HashMap数据结构 java1.7及以前 HasMap会产生死锁，java1.8及以后不会有死锁 1.7基础数据模型：数组+链表 死锁原因：HashMap在多线程的场景下，扩容期间存在节点位置互换指针引用的问题有可能导致死锁； put时：数据丢失 1.8基础数据模型：数组+链表+红黑树 *1.7中HashMap的put时扩容的源码：* /** *使用 *容量更大。当 *此映射...
哈希表实现的c++代码
09-07
当然可以，下面是一个简单的哈希表实现的 C 代码： ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #define TABLE_SIZE 10 typedef struct { char *key; int value; } Entry; typedef struct { Entry **entries; } HashTable; HashTable* createHashTable() { HashTable* hashTable = malloc(sizeof(HashTable)); hashTable->entries = calloc(TABLE_SIZE, sizeof(Entry*)); return hashTable; } int hashCode(char *key) { int hash = 0; for (int i = 0; i < strlen(key); i++) { hash += key[i]; } return hash % TABLE_SIZE; } void insert(HashTable* hashTable, char *key, int value) { int index = hashCode(key); Entry* entry = malloc(sizeof(Entry)); entry->key = strdup(key); entry->value = value; if (hashTable->entries[index] == NULL) { hashTable->entries[index] = entry; } else { // Handle collision: Linear probing int newIndex = (index + 1) % TABLE_SIZE; while (hashTable->entries[newIndex] != NULL) { newIndex = (newIndex + 1) % TABLE_SIZE; } hashTable->entries[newIndex] = entry; } } int get(HashTable* hashTable, char *key) { int index = hashCode(key); if (hashTable->entries[index] != NULL && strcmp(hashTable->entries[index]->key, key) == 0) { return hashTable->entries[index]->value; } else { // Handle collision int newIndex = (index + 1) % TABLE_SIZE; while (hashTable->entries[newIndex] != NULL && strcmp(hashTable->entries[newIndex]->key, key) != 0) { newIndex = (newIndex + 1) % TABLE_SIZE; } if (hashTable->entries[newIndex] != NULL && strcmp(hashTable->entries[newIndex]->key, key) == 0) { return hashTable->entries[newIndex]->value; } else { return -1; // Key not found } } } void freeHashTable(HashTable* hashTable) { for (int i = 0; i < TABLE_SIZE; i++) { if (hashTable->entries[i] != NULL) { free(hashTable->entries[i]->key); free(hashTable->entries[i]); } } free(hashTable->entries); free(hashTable); } int main() { HashTable* hashTable = createHashTable(); // Inserting values into hash table insert(hashTable, "apple", 5); insert(hashTable, "banana", 10); insert(hashTable, "orange", 15); // Getting values from hash table printf("Value for key 'apple': %d\n", get(hashTable, "apple")); printf("Value for key 'banana': %d\n", get(hashTable, "banana")); printf("Value for key 'orange': %d\n", get(hashTable, "orange")); printf("Value for key 'watermelon': %d\n", get(hashTable, "watermelon")); freeHashTable(hashTable); return 0; } ``` 这个代码使用了线性探测法来处理哈希冲突。在插入操作中，如果发生冲突，会往后查找空槽位，直到找到一个空槽位或者遍历完整个哈希表。在查找操作中，如果发生冲突，会往后查找直到找到对应的键或者遍历完整个哈希表。由于这只是一个简单的示例，所以哈希表的大小是固定的。在实际使用中，我们可能会采用更复杂的解决冲突的方法，并且根据需要动态调整哈希表的大小。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值