hashTable(哈希表)Java实现

最新推荐文章于 2024-07-25 08:55:54 发布
最新推荐文章于 2024-07-25 08:55:54 发布
阅读量196 收藏
点赞数 1
分类专栏： 数据结构与算法[体系] 文章标签： 链表 数据结构 java 算法 hash
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44236958/article/details/111124551
版权

hashTable(哈希表)

文章目录

哈希表的介绍

哈希表(Hashtable 也叫散列表) 是根据关键码值(key value) 而直接进行访问的数据结构,也就是说他是用过关键码值映射到表中一个位置来访问记录,以加快访问进度,这个映射函数叫做散列函数， 存放记录的数组叫做散列表

详细的hash请看

在这里插入图片描述

应用:

google 公司的一个上机题

有一个公司,当有新的员工来报道时,要求将该员工的信息加入(id,性别,年龄,名字,住址…),当输入该员工的 id 时,
要求查找到该员工的 所有信息.

要求

  1. 不使用数据库,速度越快越好=>哈希表(散列)
  2. 添加时， 保证按照 id 从低到高插入 [课后思考： 如果 id 不是从低到高插入， 但要求各条链表仍是从低到
    高， 怎么解决?]
  3. 使用链表来实现哈希表, 该链表不带表头[即: 链表的第一个结点就存放雇员信息]
  4. 思路分析并画出示意图

hashtable分析

在这里插入图片描述

总结

  • 由哈希表的结构我们知道
  • 哈希表 由数组队应得 链表 链表对应得键值 构成

键值(雇员)

class Emp {
	public int id;
	public String name;
	public Emp next; //next 默认为 null
	public Emp(int id, String name) {
		super();
		this.id = id;
		this.name = name;
	}
}

链表(存放雇员)

创建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;
	}
	...
	...
	...
}

创建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();
		}
	}
.....
.....
}

具体操作

add: 添加雇员
在hashtable中
	//添加雇员
	public void add(Emp emp) {
		//根据员工的id ,得到该员工应当添加到哪条链表
		int empLinkedListNO = hashFun(emp.id);
		//将emp 添加到对应的链表中
		empLinkedListArray[empLinkedListNO].add(emp);
		
	}
//添加雇员到链表
	//说明
	//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;
	}

list: 显示雇员

遍历所有的链表,遍历hashtab

	//遍历所有的链表,遍历hashtab
	public void list() {
		for(int i = 0; i < size; i++) {
			empLinkedListArray[i].list(i);
		}
	}

//遍历链表的雇员信息

	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\t", curEmp.id, curEmp.name);
			if(curEmp.next == null) {//说明curEmp已经是最后结点
				break;
			}
			curEmp = curEmp.next; //后移，遍历
		}
		System.out.println();
	}

find: 查找雇员

在Hashtable中

	public void findEmpById(int id) {
		//使用散列函数确定到哪条链表查找
		int empLinkedListNO = hashFun(id);
		Emp emp = empLinkedListArray[empLinkedListNO].findEmpById(id);
		if(emp != null) {//找到
			System.out.printf("在第%d条链表中找到 雇员 id = %d\n", (empLinkedListNO + 1), id);
		}else{
			System.out.println("在哈希表中，没有找到该雇员~");
		}
	}
	
	//编写散列函数, 使用一个简单取模法
	public int hashFun(int id) {
		return id % size;
	}

链表中

	//根据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;
	}

完整代码

package com.nie.Bzhan;

import java.util.Scanner;

public class HashTableDemo {
    public static void main(String[] args) {
        HashTab tab = new HashTab(7);
        //写一个简单的菜单
        String key = "";
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.println("a:  添加雇员");
            System.out.println("l: 显示雇员");
            System.out.println("f: 查找雇员");
            System.out.println("e: 退出系统");
            key = scanner.next();
            switch (key) {

                case "a":
                    System.out.println("输入id");
                    int id = scanner.nextInt();
                    System.out.println("输入名字");
                    String name = scanner.next();
                    //创建雇员
                    Emp emp = new Emp(id, name);
                    tab.add(emp);
                    break;
                case "l":
                    tab.List();
                    break;

                case "f":
                    System.out.println("请输入要查找的id");
                    id = scanner.nextInt();
                    tab.findEmpById(id);
                    break;
                case "e":
                    scanner.close();
                    System.exit(0);
                default:
                    break;
            }


        }
    }
}

//表示一个雇员 即 哈希表中链表中的结点
class Emp {
    public int id;
    public String name;
    public Emp next;

    public Emp(int id, String name) {
        this.id = id;
        this.name = name;
    }
}

//创建链表
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;
        }
        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\t", curEmp.id, curEmp.name);
            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("此链表为空");
        }
        Emp curEmp = head;
        while (true) {
            //找到返回
            if (curEmp.id == id) {
                break;
            }
            //没有找到返回null
            //退出
            if (curEmp.next == null) {
                curEmp = null;
                break;
            }
            curEmp = curEmp.next;//向后遍历
        }
        return curEmp;
    }

}


//创建hashtab 管理多条链表
class HashTab {

    private EmpLinkedList[] empLinkedListArray;
    private int size;//表示有多少链表

    //构造器
    HashTab(int size) {
        this.size = size;
        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);

    }

    //根据输入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\n", (empLinkedListNO + 1), id);
        } else {
            System.out.println("在哈希表中，没有找到该雇员~");
        }
    }

    //遍历所有的链表 遍历hashtab
    public void List() {
        for (int i = 0; i < size; i++) {
            empLinkedListArray[i].list(i);
        }
    }

    private int hashFun(int id) {
        return id % size;
    }

}

在这里插入图片描述

靠谱的大钊
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中哈希表的实现
qq_45846957的博客
08-15 777
java哈希表
哈希表-使用Java开发的哈希表-HashTable.zip
03-04
在Java中，`HashTable`是早期版本（Java 1.0）提供的一种线程安全的哈希表实现。尽管现在已经被`HashMap`所替代，但理解`HashTable`的工作原理和特性仍然对深入理解Java集合框架以及数据结构有重要意义。 哈希表的...
哈希表（Java实现）
WYSCODER的博客
02-04 7457
哈希表（Java实现）
Java实现哈希表
qq_44300280的博客
04-26 2078
Java实现哈希表
Java实现哈希表（散列表）
qq_64431576的博客
09-16 2202
Java实现哈希表（散列表）
数据结构-哈希表（java实现）
weixin_45627194的博客
12-18 2562
文章目录1、哈希表介绍2、哈希函数H（k）哈希函数的构造方法：（1）直接定址法（2）数字分析法（3）平方取中法（4）折叠法（5）除留余数法（6）随机数法3、解决哈希碰撞1、开放地址法2、链地址法（拉链法）4、实例：使用哈希表管理雇员信息 1、哈希表介绍 散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。（哈希表本质上就是个数组，
哈希表java实现
猪奥奥的Blog
06-10 3761
哈希表一、基本概念二、代码实现 一、基本概念 散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(Hash）表，函数f(key)为哈希(Hash) 函数。 结构 哈希表的结构可以使用数组+链表实现，
哈希表(Java实现)
愿你有前程可奔赴，亦有青春可回顾
03-13 1557
基本介绍 代码实现 package com.xz.hashtab; import java.util.Scanner; /** * @author 许正 * @version 1.0 */ public class HashTabDemo { public static void main(String[] args) { //创建HashTab HashTab hashTab = new HashTab(7); //写一个简单的菜单
哈希表（Java语言实现一个哈希表）
qq_49306008的博客
10-19 1457
1、哈希表的基本介绍 哈希表（Hash table，也叫散列表），是根据关键码值（Key value）而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中的一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 需求：有一个公司，当有新员工来报道时，要求将该员工的信息加入，当输入该员工的id时，要求查找到该员工的信息。当该员工离开公司时，删除他的信息。 要求：不使用数据库，速度越快越好 添加时，id从低到高。 使用链表来实现哈希表，该链表不带头节点 代码实现：
Java数据结构-哈希表的实现(hash)
算法萌新一枚
03-26 3684
我想给大家介绍的是哈希表,当我们学集合的时候一定会接触到hashtable,我们却不明白为什么要同时重写equals方法和hashCode方法,今天,我就带大家了解哈希表底层,让大家彻底弄懂哈希表.哈希表的概述 🔜 哈希表的创建思路🔜 哈希表的代码实现与分析🔜 结论
Java简单实现链式哈希表
zt的博客
02-03 1929
文章目录什么是哈希表试题代码输出结果 什么是哈希表 散列表（Hash table 也叫哈希表），是通过关键码值（key value）而直接进行访问的数据结构。也就是说，它通过关键码值映射到表中的一个位置来访问记录，以加快查找的速度。这个映射函数也叫散列函数，存放记录的数组也叫散列表。 试题 有一个公司，当有新员工来报道时，要求将员工的信息加入（id，性别，年龄，名字，住址），当输入员工的id时要求查找到员工的所有信息。 要求： 不使用数据库，速度越快越好。 代码 Emp：雇员类模拟结点 public cl
哈希表java实现及简单演示
09-11
标签中的`hashtable`可能指的是`java.util.Hashtable`类，这是Java早期提供的一种线程安全的哈希表实现。虽然`HashMap`在性能上通常优于`Hashtable`，但`Hashtable`在多线程环境中更安全，因为它的所有方法都是同步...
java中哈希表及其应用详解
09-03
在Java中，哈希表的实现主要体现在`Hashtable`类中，它是`Dictionary`类的子类，并且实现了`Map`接口。`Hashtable`内部使用了一个`Entry`类来保存单元数据，每个`Entry`实例都包含一个键和一个值，它们共同构成了...
java hashtable实现代码
09-04
Java中的`Hashtable`类是Java集合框架的一部分，它是一个基于哈希表的Map接口实现。这个数据结构允许我们以键值对的形式存储数据，并且提供了快速的插入、删除和查找操作。`Hashtable`是线程安全的，因此可以在多...
HashTable的java实现
01-22
在Java编程语言中，哈希表（HashTable）是一种常见的数据结构，它提供了高效的数据存储和检索功能。哈希表基于哈希函数将键（Key）映射到数组的索引位置，通过键值对（Key-Value Pair）来存储数据。这种数据结构允许...
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 293
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
数据结构之初始二叉树（4）
我要学编程的博客
07-22 1408
二叉树的前序遍历、二叉树的层序遍历、根据二叉树的前序和中序遍历构造二叉树、二叉树的最近公共祖先、根据二叉树创建字符串
【JavaScript】`Map` 数据结构
最新发布
lph159的博客
07-25 357
允许您使用各种类型的值作为键，不限于字符串或符号。按照插入顺序保留键值对，而对象的键的遍历顺序可能会根据不同的 JavaScript 引擎有所不同。的基本概念、用法、常见操作以及与对象的对比，帮助您全面掌握这一数据结构。与传统的对象（Object）不同，和对象在某些方面类似，但它们在使用场景和性能上有一些显著区别。保留了键值对的插入顺序，且键是唯一的，这意味着在同一个。对象适用于结构化的静态数据，而。是一种键值对集合，其中键和值都可以是任意类型。对象的键只能是字符串或符号，而。更适合需要动态操作的场景。
【数据结构】队列
2302_78914800的博客
07-25 211
①队列是一个有序列表，可以用。
哈希表数据结构JAVA实现
01-19
以下是哈希表数据结构的JAVA实现示例： ```java import java.util.LinkedList; public class HashTable { private LinkedList[] table; private int capacity; public HashTable(int capacity) { this....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值