1. Toy模板网首页
  2. > Toy博客

哈希表（Hash Table）-----运用实例【通过哈希表来管理雇员信息】（java详解） (✧∇✧)

7月前 作者：IYF.星辰 分类：Toy博客 阅读(29) 违法举报

这篇具有很好参考价值的文章主要介绍了哈希表（Hash Table）-----运用实例【通过哈希表来管理雇员信息】（java详解） (✧∇✧)。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

目录

一.哈希表简介：

实例介绍：

 类的创建与说明：

各功能图示：

 1.class HashTab{  }; 

2. class EmpLinkedList{ }；

3. class Emp{ }；

4.测试：

运行结果：

最后，完整代码：

一.哈希表简介：

哈希表（Hash Table）：也叫做散列表。是根据关键码值（Key Value）直接进行访问的数据结构。

哈希表通过「键 key 」和「映射函数 Hash(key) 」计算出对应的「值 value」，把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做「哈希函数（散列函数）」，存放记录的数组叫做「哈希表（散列表）」。

 使用方法：

  • 向哈希表中插入一个关键码值：哈希函数决定该关键字的对应值应该存放到表中的哪个区块，并将对应值存放到该区块中。

  • 在哈希表中搜索一个关键码值：使用相同的哈希函数从哈希表中查找对应的区块，并在特定的区块搜索该关键字对应的值。

  • 实现哈希表： 数组+链表 或者  数组+二叉树

 原理示意图：

哈希表（Hash Table）-----运用实例【通过哈希表来管理雇员信息】（java详解） (✧∇✧),java数据结构与算法,散列表,数据结构

 由于这篇博客主要讲应用栗子，就不做哈希表的过多说明，如有需要，可以看看这篇博客：数据结构之—哈希表_哈希表数据结构-CSDN博客

实例介绍：

 有一个公司,当有新的员工来报道时,要求将该员工的信息加入 (id,性别,年龄,名字,住址..),当输入该员工的id时,要求查找到该员工的 所有信息。这里用数组+链表来实现

 类的创建与说明：

  • class HashTab{  };  
    创建HashTab管理多条链表
  • class EmpLinkedList{ }; 
    创建EmpLinkedList ,表示链表
  • class Emp{ }； 
    创建Emp，表示雇员

各功能图示：

 哈希表（Hash Table）-----运用实例【通过哈希表来管理雇员信息】（java详解） (✧∇✧),java数据结构与算法,散列表,数据结构

 1.class HashTab{  }; 

//创建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\n", (empLinkedListNO + 1), id);
        }else{
            System.out.println("在哈希表中，没有找到该雇员~");
        }
    }
    //根据输入的id删除雇员
    public void delEmp(int id){
       int empLinkListNO = hashFun(id);//先查找在第几个链表中
       empLinkedListArray[empLinkListNO].delEmp(id);//然后执行删除操作
        System.out.println("删除完成");
    }

    //编写散列函数, 使用一个简单取模法
    public int hashFun(int id) {
        return id % size;
    }


}

2. class EmpLinkedList{ }；

//创建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\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("链表为空");
            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;
    }

    public void delEmp(int id){
       Emp emp = findEmpById(id);//先找到雇员在删除
       if(emp == null){
           System.out.println("没有找到该雇员");
       }
       Emp curEmp = head;
       while(true){
           if(emp == head){//分两种情况进行删除
               head = head.next;//1.要删除的雇员在头节点处，直接让头指针指向下一个节点即可
               break;
           }
           if(curEmp.next == emp){//2.要删除的雇员不在头节点处，先找到位置在删除
               curEmp = curEmp.next.next;
               break;
           }
           curEmp = curEmp.next;
       }
    }
}

3. class Emp{ }；

//表示一个雇员
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;
    }
}

4.测试：

public class HashTabDemo {

    public static void main(String[] args) {

        //创建哈希表
        HashTab hashTab = new HashTab(7);

        //写一个简单的菜单
        String key = "";
        Scanner scanner = new Scanner(System.in);
        while(true) {
            System.out.println("add:  添加雇员");
            System.out.println("list: 显示雇员");
            System.out.println("find: 查找雇员");
            System.out.println("del:  删除雇员");
            System.out.println("exit: 退出系统");

            key = scanner.next();
            switch (key) {
                case "add":
                    System.out.println("输入id");
                    int id = scanner.nextInt();
                    System.out.println("输入名字");
                    String name = scanner.next();
                    //创建 雇员
                    Emp emp = new Emp(id, name);
                    hashTab.add(emp);
                    break;
                case "list":
                    hashTab.list();
                    break;
                case "find":
                    System.out.println("请输入要查找的id");
                    id = scanner.nextInt();
                    hashTab.findEmpById(id);
                    break;
                case "del":
                    System.out.println("请输入要删除的id");
                    id = scanner.nextInt();
                    hashTab.delEmp(id);
                    break;
                case "exit":
                    scanner.close();
                    System.exit(0);
                default:
                    break;
            }
        }

    }

}

运行结果：

哈希表（Hash Table）-----运用实例【通过哈希表来管理雇员信息】（java详解） (✧∇✧),java数据结构与算法,散列表,数据结构

最后，完整代码：

import java.util.Scanner;

public class HashTabDemo {

    public static void main(String[] args) {

        //创建哈希表
        HashTab hashTab = new HashTab(7);

        //写一个简单的菜单
        String key = "";
        Scanner scanner = new Scanner(System.in);
        while(true) {
            System.out.println("add:  添加雇员");
            System.out.println("list: 显示雇员");
            System.out.println("find: 查找雇员");
            System.out.println("del:  删除雇员");
            System.out.println("exit: 退出系统");

            key = scanner.next();
            switch (key) {
                case "add":
                    System.out.println("输入id");
                    int id = scanner.nextInt();
                    System.out.println("输入名字");
                    String name = scanner.next();
                    //创建 雇员
                    Emp emp = new Emp(id, name);
                    hashTab.add(emp);
                    break;
                case "list":
                    hashTab.list();
                    break;
                case "find":
                    System.out.println("请输入要查找的id");
                    id = scanner.nextInt();
                    hashTab.findEmpById(id);
                    break;
                case "del":
                    System.out.println("请输入要删除的id");
                    id = scanner.nextInt();
                    hashTab.delEmp(id);
                    break;
                case "exit":
                    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\n", (empLinkedListNO + 1), id);
        }else{
            System.out.println("在哈希表中，没有找到该雇员~");
        }
    }
    //根据输入的id删除雇员
    public void delEmp(int id){
       int empLinkListNO = hashFun(id);//先查找在第几个链表中
       empLinkedListArray[empLinkListNO].delEmp(id);//然后执行删除操作
        System.out.println("删除完成");
    }

    //编写散列函数, 使用一个简单取模法
    public int hashFun(int id) {
        return id % size;
    }


}

//表示一个雇员
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;
    }

    //遍历链表的雇员信息
    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("链表为空");
            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;
    }

    public void delEmp(int id){
       Emp emp = findEmpById(id);//先找到雇员在删除
       if(emp == null){
           System.out.println("没有找到该雇员");
       }
       Emp curEmp = head;
       while(true){
           if(emp == head){//分两种情况进行删除
               head = head.next;//1.要删除的雇员在头节点处，直接让头指针指向下一个节点即可
               break;
           }
           if(curEmp.next == emp){//2.要删除的雇员不在头节点处，先找到位置在删除
               curEmp = curEmp.next.next;
               break;
           }
           curEmp = curEmp.next;
       }
    }
}

博客到这里也是结束了，制作不易，喜欢的小伙伴可以点赞加关注支持下博主，这对我真的很重要~~

哈希表（Hash Table）-----运用实例【通过哈希表来管理雇员信息】（java详解） (✧∇✧),java数据结构与算法,散列表,数据结构文章来源地址https://www.toymoban.com/news/detail-830813.html

到了这里，关于哈希表（Hash Table）-----运用实例【通过哈希表来管理雇员信息】（java详解） (✧∇✧)的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • Java学数据结构（4）——散列表Hash table & 散列函数 & 哈希冲突

    Java学数据结构（4）——散列表Hash table & 散列函数 & 哈希冲突

    1.散列表，key，散列函数； 2.哈希冲突的解决； 3.string中的hashCode; 查找树ADT,它允许对元素的集合进行各种操作。本章讨论散列表(hash table)ADT,不过它只支持二叉查找树所允许的一部分操作。散列表的实现常常叫作散列(hashing)。散列是一种用于以常数平均时间执行插入、删除和

    2024年02月10日
    浏览(47)

  • leetcode分类刷题：哈希表（Hash Table）（四、前缀和 处理连续子数组）

    1、leetcode题目里对于 元素加和 的考察可谓是屡见不鲜，包括 简单的限定一个有效答案 的两个或多个元素求和leetcode分类刷题：哈希表（Hash Table）（一、简单的两数之和）、在有序数组内对加和等于target的 三元组、四元组 等的求解leetcode分类刷题：基于数组的双指针（三、

    2024年02月10日
    浏览(25)
  • 哈希（hash）

    哈希（hash）

    目录 一、什么是哈希 二、哈希冲突 三、哈希函数 3.1、哈希函数设计原则 3.2、常见的哈希函数 四、哈希冲突解决 4.1、闭散列 4.2、开散列 五、哈希表的模拟实现 5.1、哈希表的功能模拟实现 5.2、测试模拟实现： 如果构造一种存储结构，可以通过某种函数 (hashFunc) 使元素的存

    2024年01月17日
    浏览(33)
  • redis—Hash哈希

    redis—Hash哈希

    目录 前言 1.常见命令 1.1命令小结 1.2内部编码 2.使用场景 几乎所有的主流编程语言都提供了哈希(hash) 类型，它们的叫法可能是哈希、字典、关联数组、映射。在Redis中，哈希类型是指值本身又是一个键值对结构，形如key= \\\"key\\\", value={{ field1, value1 }, ... {fieldN, valueN }}, Redis 键值对

    2024年02月04日
    浏览(35)

  • Redis 哈希（ Hash ）

    【一】简介   Redis hash 是一个键值对集合。  Redis hash 是一个 string 类型的  field  和  value  的映射表， hash 特别适合用于存储对象。 类似 Java 里面的 Map String , Object   用户 ID 为查找的 key ，存储的 value 用户对象包含姓名，年龄，生日等信息，如果用普通的 key/value 结构来存

    2024年02月12日
    浏览(38)

  • 哈希（Hash）的详细介绍

            ~~~~~~~               Hash，一般翻译做散列、杂凑，或音译为哈希，是把任意长度的 输入 （又叫做预映射pre-image）通过散列算法变换成固定长度的 输出 ，该输出就是散列值。 这种转换是一种压缩映射,也就是，散列值的空间通常远小于输入的空间，不同的输入可

    2024年02月13日
    浏览(32)
  • 【Redis】Redis 哈希 Hash 键值对集合操作 ( 哈希 Hash 键值对集合简介 | 查询操作 | 增加操作 | 修改操作 )

    【Redis】Redis 哈希 Hash 键值对集合操作 ( 哈希 Hash 键值对集合简介 | 查询操作 | 增加操作 | 修改操作 )

    Redis 中的 Hash 数据 是一个 键值对集合 , 类似于 Java 中的 Map 集合 ; Hash 数据底层数据结构是 : 压缩列表 ZipList : Hash 中的 键值对 长度较短时 使用 压缩列表 ; 哈希表 HashTable : Hash 中的 键值对 长度较长时 使用 哈希表 ; Redis 中存储对象的方式 : 存储序列化之后的数据 : 将 对象

    2024年02月15日
    浏览(37)
  • 哈希算法（hash）加密解密

    哈希算法（hash）加密解密

    套路一样 hash_jiemi.py

    2024年02月13日
    浏览(34)
  • Hash(哈希)算法-Python实现

    Hash(哈希)算法-Python实现

    哈希算法将任意长度的二进制值映射为较短的固定长度的二进制值，这个小的二进制值称为哈希值。哈希值是一段数据唯一且极其紧凑的数值表示形式。如果散列一段明文而且哪怕只更改该段落的一个字母，随后的哈希都将产生不同的值。要找到散列为同一个值的两个不同的

    2023年04月15日
    浏览(28)
  • Redis学习2 - 哈希(Hash)

    Redis学习2 - 哈希(Hash)

    Hash操作 Redis hash 是一个 string 类型的 field（字段） 和 value（值） 的映射表，hash 特别适合用于存储对象。 Redis 中每个 hash 可以存储 232 - 1 键值对（40多亿） 1. Hset Hset 命令用于为哈希表中的字段赋值 。 如果哈希表不存在，一个新的哈希表被创建并进行 HSET 操作。 如果字段已

    2023年04月18日
    浏览(39)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包