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

最新推荐文章于 2024-05-21 16:00:03 发布
最新推荐文章于 2024-05-21 16:00:03 发布
阅读量942 收藏 21
点赞数 21
分类专栏： java数据结构与算法 文章标签： 散列表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_79862386/article/details/136085322
版权

目录

一.哈希表简介：

实例介绍：

 类的创建与说明：

各功能图示：

 1.class HashTab{  }; 

2. class EmpLinkedList{ }；

3. class Emp{ }；

4.测试：

运行结果：

最后，完整代码：

一.哈希表简介：

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

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

 使用方法：

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

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

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

 原理示意图：

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

实例介绍：

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

 类的创建与说明：

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

各功能图示：

 

 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;
            }
        }

    }

}

运行结果：

最后，完整代码：

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;
       }
    }
}

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

IYF.星辰
关注
  • 21
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
哈希表示例
echo_bright_的博客
04-09 1692
哈希表的意义在于高效查找。对于查找来说，如果数据量特别大，二分查找和哈希表算法十分有用了。二分查找前面已经讲过，现来讲讲哈希表算法。 就像输入数据数组下标返回数组元素一样，这样的查找方式是最高效的了，哈希表就是这样一种数据结构。 假设现在有10个元素的数组，通过每一个元素可以确定它存在在哈希表中的哪一个位置(哈希表可以理解为一个特殊数组，它的数据成员也有下标)，当下次要查找该元素时候，就可以通过
最简单易懂的hash表实现代码
Sfloor的博客
02-04 649
//构造hash算法： //1.直接定址法 H(key) = key 或者 H(key) = a*key + b; //2.数字分析法 //3.平方取中法： 将数据key进行平方，根据情况随意取数据的中间几位即可 //4.折叠法： 将数据分割成位数较小的几分，然后将几份数据进行叠加。456 789 12 ——>456 789 120 以上三者相加 //5.除留余数法： H(key)
哈希表应用实例
zzwdkxx的专栏
01-20 2515
转自：http://blog.csdn.net/zouchunlaigo1988/article/details/7163920 1：问题描述         针对某个集体（比如你所在的班级）中的“人名”设计一个哈希表，使得平均查找长度不超过R，完成相应的建表和查表程序。 2：基本要求           假设人名为中国人姓名的汉语拼音形式。待填入哈希表的人名共有30个，取平均
hash表的简单说明以及例子
fenglifeng1987的专栏
08-11 3265
http://blog.csdn.net/feixiaoxing/article/details/6885657  这一篇写的很赞     数组的特点是：寻址容易，插入和删除困难；而链表的特点是：寻址困难，插入和删除容易。hash表可以解决以上两个不足之处。            假如你要在图书馆里找一本《电路原理》，这本书首先它在工科类下面，再在工科类的电子信息这个分类里面，你首先要找到工科
JAVA-hash-table.zip_Table_hash_hash table java_java hash 查找_哈希表设
09-20
（1） 建立一个哈希表，哈希函数为除留余数法，处理冲突的方法为线性探测再散列或二次探测再散列。 （2） 往哈希表中依次存入插入多个单词。 （3） 显示哈希表的存储情况。 （4） 计算哈希表的平均查找长度。 （5） ...
第1章 哈希和哈希表-2020.08.19.pdf
09-05
第1章 哈希和哈希表-2020.08.19 第1章 哈希和哈希表-2020.08.19 第1章 哈希和哈希表-2020.08.19 第1章 哈希和哈希表-2020.08.19 第1章 哈希和哈希表-2020.08.19
哈希表-使用Java开发的哈希表-HashTable.zip
03-04
哈希表 哈希表_使用Java开发的哈希表_HashTable
哈希表-使用C语言实现哈希表数据结构-HashTable.zip
03-04
哈希表 哈希表_使用C语言实现哈希表数据结构_HashTable
基于java的开发源码-哈希计算工具 Java-hash.zip
02-24
基于java的开发源码-哈希计算工具 Java-hash.zip 基于java的开发源码-哈希计算工具 Java-hash.zip 基于java的开发源码-哈希计算工具 Java-hash.zip 基于java的开发源码-哈希计算工具 Java-hash.zip 基于java的开发...
hash实例讲解
热门推荐
basycai的博客
07-11 1万+
from http://blog.jobbole.com/49229/ 说明：本文分为三部分内容，第一部分为一道百度面试题Top K算法的详解；第二部分为关于Hash表算法的详细阐述；第三部分为打造一个最快的Hash表算法。 第一部分：Top K 算法详解 问题描述 百度面试题： 搜索引擎会通过日志文件把用户每次检索使用的所有检索串都记录下来，每个查询串的长度为1-2
hash-table基础以及一些运用例子
stefan1240的专栏
07-31 7840
最近在复习算法和数据结构 ，这章把hash表的概念和相关题目进行汇总。 0、前言 0.1、哈希表和数组、以及链表的对比： (1).数组的特点：寻址容易，插入和删除困难； 数组存储连续,查找一个元素的时间复杂度为O(1)； (2).链表的特点：寻址困难，插入和删除容易。链表存储区是离散的，遍历链表的元素的时间复杂度为O(N)。 (3).hash-table是根据关键值（key-value）来直接进行访问的数据结构，它结合了数组和链表的优点。
Java集合——HashMap和Hashtable应用实例
3100804034的博客
02-26 1108
package com.shuzu; import java.util.HashMap; import java.util.Iterator; public class HashMapTest { public static void main(String[] args) { // TODO Auto-generated method stub Student s1 = new
Hashtable案例
weixin_30482181的博客
05-10 101
package tushu; import java.util.Hashtable; import java.util.Map; import java.util.Map.Entry; import java.util.Set; public class TestHashtable { public static void main(String[] args)...
HashTable一个小例子
qq2613的专栏
11-30 1419
页面添加两个ListBox控件 private static Hashtable parmCache=Hashtable.Synchronized(new Hashtable()); protected void Page_Load(object sender, EventArgs e) { if(!IsPostBack) {
数据结构之哈希表HashTable实例讲解
青山师
06-06 5237
哈希表 是一种以关联方式存储数据的数据结构，在哈希表中，数据以数组格式存储，其中每个数据值都有自己唯一的索引。如果我们知道所需数据的索引，那么数据的访问就会变得非常快。 所以关键是 找到索引， 而检索 数值关键字 到 索引 的方式就是 哈希（Hashing）。 因此，在这个结构中插入和搜索操作非常快，不管数据的大小。哈希表使用数组作为存储介质，并使用散列技术（就是我们的哈希算法）生成一个索引。 ...
hashtable的运用实例
MA201506的博客
10-30 153
1 #include <hash_set> 2 #include <iostream> 3 using namespace std; 4 int main() 5 { 6 hashtable<int, 7 int, 8 hash<int>, 9 iden...
C语言/数据结构——每日一题（用栈实现队列）
最新发布
yiqingaa的博客
05-21 268
前面我们已经学习了和。
【数据结构】一文了解二叉树的顺序结构（堆）
tidal_wave的博客
05-18 751
普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。以上就是今天要讲的内容，本文仅仅简单介绍了堆的使用，而堆提供了大量能使我们快速便捷地处理数据的思路。以后博主会继续介绍二叉树的其他知识，期待你的阅读。
c语言 使用哈希表代替 switch-case 语句
04-26
好的，我知道你的问题是关于使用哈希表来代替 switch-case 语句的相关内容。哈希表是一种非常有效的数据结构，它可以帮助我们快速地查找给定键的值。在C语言中，我们可以使用哈希表来代替 switch-case 语句，使代码...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值