08-java数据结构之哈希表的详解

已于 2022-10-24 20:40:56 修改
阅读量270 收藏 1
点赞数 1
分类专栏： java数据结构 文章标签： 1024程序员节
于 2022-10-24 20:40:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56469942/article/details/127500752
版权

目录

1、哈希表的基本介绍

1.2、哈希表的冲突介绍

2、哈希表（散列）----Google上机题

3、代码实现

3.1、思路分析图

3.2、代码实现

3.2.1、创建一个雇员类

3.2.2、创建一个链表类

3.2.3、创建一个管理多条链表类

3.2.4、创建一个主类

3.2.5、完整代码以及测试结果

1、哈希表的基本介绍

        散列表（也称哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。增映射函数叫做散列函数，存放记录的数组叫做散列表。

 

        数组和向量都可以存储对象，但对象的存储位置是随机的，也就是说对象本身与其存储位置之间没有必然的联系。当要查找一个对象时，只能以某种顺序（如顺序查找或二分查找）与各个元素进行比较，当数组或向量中的元素数量很多时，查找的效率会明显的降低。

        一种有效的存储方式，是不与其他元素进行比较，一次存取便能得到所需要的记录。这就需要在对象的存储位置和对象的关键属性（设为 k）之间建立一个特定的对应关系（设为 f），使每个对象与一个唯一的存储位置相对应。在查找时，只要根据待查对象的关键属性 k 计算f(k)的值即可。如果此对象在集合中，则必定在存储位置 f(k)上，因此不需要与集合中的其他元素进行比较。称这种对应关系 f 为哈希（hash）方法，按照这种思想建立的表为哈希表

1.2、哈希表的冲突介绍

        假设哈希表的地址集为，冲突是指由关键字得到的哈希地址为的位置上已存有记录，则“处理冲突”就是为该关键字的记录找到另一个“空”的哈希地址。
     在处理冲突的过程中可能得到一个地址序列。即在处理哈希地址的冲突时，若得到的另一个哈希地址仍然发生冲突，则再求下一个地址，若仍然冲突，再求，依次类推，直至不发生冲突为止，则为记录在表中的地址。
（需要注意此定义不太适合链地址法）

2、哈希表（散列）----Google上机题

1） 看一个实际需求
2）有一个公司，当有新的员工来报道时，要求将该员工的信息加入(id，性别，年龄，住址…)，当输入该员工的id时，要求查找到该员工的所有信息。
3）要求：不使用数据库，尽量节省内存，速度越快越好==>哈希表（散列）

3、代码实现

3.1、思路分析图

3.2、代码实现

3.2.1、创建一个雇员类

// 表示一个雇员
class Emp{
    public int id;
    public String name;
    public Emp next; //next默认为null

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

3.2.2、创建一个链表类

// 管理雇员，表示链表
class EmpLinkedList{
    // 头指针
    private  Emp head;


    // 添加雇员到链表 id自增长
    public void add(Emp emp){
        // 如果是添加的第一个雇员
        if(head==null){
            // 我们创建的链表不需要带头
            head=emp;
            return;
        }
        // 如果不是第一个雇员，则需要使用一个辅助变量，帮助定位到最后
        Emp curEmp=head;
        while(true){
            if(curEmp==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){
                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;
            }
            if(curEmp.next==null){
                curEmp=null;
                break;
            }
            curEmp=curEmp.next;
        }
        return curEmp;
    }
}

3.2.3、创建一个管理多条链表类

// 创建HashTab 管理多条链表
class HashTab{
    private EmpLinkedList[] empLinkedListArry;
    private int size; //表示有多少条链表

    public HashTab(int size) {
       this.size=size;
       empLinkedListArry=new EmpLinkedList[size];
       for(int i=0;i<size;i++){
           empLinkedListArry[i]=new EmpLinkedList();
       }
    }

    // 添加雇员
    public void add(Emp emp){
        // 根据员工id，得到该员工应添加到哪条链表
        int empLinkListNo=hashFun(emp.id);
        // 将emp添加到对应的链表中
        empLinkedListArry[empLinkListNo].add(emp);
    }

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

    // 根据输入id，查找雇员
    public void findEmpById(int id){
        //使用散列函数确定到哪条链表查找
        int empLinkedListNo=hashFun(id);
        Emp emp = empLinkedListArry[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;
    }
}

3.2.4、创建一个主类

public class hashTableTest {
    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("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 "exit":
                    scanner.close();
                    System.exit(0);
                default:
                    break;
            }
        }

    }
}
}

3.2.5、完整代码以及测试结果

public class hashTableTest {
    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("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 "exit":
                    scanner.close();
                    System.exit(0);
                default:
                    break;
            }
        }

    }
}


// 创建HashTab 管理多条链表
class HashTab{
    private EmpLinkedList[] empLinkedListArry;
    private int size; //表示有多少条链表

    public HashTab(int size) {
       this.size=size;
       empLinkedListArry=new EmpLinkedList[size];
       for(int i=0;i<size;i++){
           empLinkedListArry[i]=new EmpLinkedList();
       }
    }

    // 添加雇员
    public void add(Emp emp){
        // 根据员工id，得到该员工应添加到哪条链表
        int empLinkListNo=hashFun(emp.id);
        // 将emp添加到对应的链表中
        empLinkedListArry[empLinkListNo].add(emp);
    }

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

    // 根据输入id，查找雇员
    public void findEmpById(int id){
        //使用散列函数确定到哪条链表查找
        int empLinkedListNo=hashFun(id);
        Emp emp = empLinkedListArry[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;
    }
}

// 管理雇员，表示链表
class EmpLinkedList{
    // 头指针
    private  Emp head;


    // 添加雇员到链表 id自增长
    public void add(Emp emp){
        // 如果是添加的第一个雇员
        if(head==null){
            // 我们创建的链表不需要带头
            head=emp;
            return;
        }
        // 如果不是第一个雇员，则需要使用一个辅助变量，帮助定位到最后
        Emp curEmp=head;
        while(true){
            if(curEmp==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){
                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;
            }
            if(curEmp.next==null){
                curEmp=null;
                break;
            }
            curEmp=curEmp.next;
        }
        return curEmp;
    }
}


// 表示一个雇员
class Emp{
    public int id;
    public String name;
    public Emp next; //next默认为null

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

 

 

 

 

♚ 无趣
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
JAVA数据结构之哈希表
砥砺前行的博客
04-11 1741
●散列表（Hash table， 也叫哈希表） ，是根据关键码值(Key value)而直接进行访问的数据结构。●它通过把关键码值映射到表中一个位置来访问记录， 以加快查找的速度。这个映射函数叫做散列函数， 存放记录的数组叫做散列表。●哈希表的核心：private EmpLinkedList[] empLinkedListArray;●哈希表编程思路：先根据对象的信息将其散列，得到 hashCode根据对象的 hashCode 值，找到对应的数组下标，其实就是找到存储对象的链表。
哈希表及其基础（java详解）
xiaoliii0401的博客
12-06 2120
这么详细你还拿不下哈希表？我不信。
Java数据结构——哈希表
最新发布
m0_74808313的博客
05-06 674
哈希散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。
Java哈希表详解
qq_65501447的博客
11-09 208
中，元素关键码与其存储位置之间没有对应的关系，因此在。，搜索的效率取决于搜索过程中元素的比较次数。所以需要一个查找效率比较快的结构如果有一种结构 不需要数据的比较就能够找到搜索的元素，那么这种结构就是我们理想的结构，它的查找的时间复杂度为O(1)。对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功。该方式即为哈希散列方法，
JAVA——哈希表
qq_35706707的博客
03-31 373
哈希表的定义 1.哈希表定义：Map<String, Integer> counts = new HashMap(); 创建特定的hash表：Map<Integer,Integer>counts=new HashMap<Integer, Integer>(); 左边的是key右边的是value 2.创建单个字符的键值对：Map<Char...
Java数据结构：散列表
baidu_30130783的博客
08-20 383
1、散列函数 将任意长度的二进制值串映射为固定长度的二进制值串，这个映射的规则就是哈希算法。如MD5,就是一种被广泛使用的密码散列函数。 MD5(12)=C20AD4D76FE97759AA27A0C99BFF6710 MD5(123)=202CB962AC59075B964B07152D234B70 2、散列表 散列表（Hash table，也叫哈希表），就是通过散列函数将关键码...
java数据结构和算法中哈希表知识点详解
08-25
_java数据结构和算法中哈希表知识点详解_ 哈希表是一种数据结构，提供很快速的插入和查找操作，时间复杂度为O(1)，对比时间复杂度就可以知道哈希表比树的效率快得多。然而没有任何一种数据结构是完美的，哈希表也是...
Java数据结构-HashMap详解
08-26
Java数据结构中的HashMap是一种基于哈希表的数据结构，它提供了高效的存储和检索机制。HashMap的实现基于数组和链表（或红黑树）的结合，根据哈希冲突的长度不同，进行不同的存储和查找策略。 在HashMap中，哈希...
Java数据结构：详解及使用场景.pdf
11-18
这些Java数据结构在实际编程中有着广泛的应用。例如： - 数组适用于存储固定大小且类型相同的元素集合，常用于基础计算和内存效率要求高的场景。 - 列表（如ArrayList和LinkedList）在需要动态调整大小和频繁增删...
数据结构与算法代码详解JAVA版
08-26
本资源"数据结构与算法代码详解JAVA版"聚焦于使用Java语言来理解和实现这些核心概念。 首先，数据结构是组织和存储数据的方式，它为高效地执行各种操作提供了便利。常见的数据结构包括数组、链表、栈、队列、树（如...
Java 集合与数据结构详解1
08-03
本文将深入探讨Java集合框架的核心概念、数据结构以及相关的算法。 首先，集合框架主要由两个核心部分组成：集合（Collection）和图（Map）。集合是用来存储单一元素的容器，而图则用于存储键值对映射关系。在...
Java数据结构之散列表(动力节点Java学院整理)
08-30
散列表(Hash table，也叫哈希表)，是根据关键字(key value)而直接进行访问的数据结构。这篇文章给大家介绍了java数据结构之散列表，包括基本概念和散列函数相关知识，需要的的朋友参考下吧
散列表的基本原理与实现
weixin_30307921的博客
05-19 1090
本篇博文主要介绍散列表（Hash Table）这一常见数据结构的原理与实现。由于个人水平有限，文章中难免存在不准确或是不清晰的地方，希望大家可以指正：） 一、概述 符号表是一种用于存储键值对（key-value pair）的数据结构，我们平常经常使用的数组也可以看做是一个特殊的符号表，数组中的“键”即为数组索引，值为相应的数组元素。也就是说，当符号表中所有的键都是较小的整数时...
JAVA哈希表的构建（拉链法）
Alexwym的博客
07-15 5715
哈希表是一个用途很广泛的数据结构，常用于需要进行大集合搜索的地方，比如腾讯QQ。对于上线的用户我们需要将其添加到一个集合中，以便对其进行各种处理。那么这个集合该采取哪种数据结构呢？最基本的数据结构就两种：链表和数组。在前面的文章中，我们曾经比较过链表和数组的优缺点。链表适用于插入和删除操作较多的集合，但是不适用于取值操作多的集合。而数组不适用于插入和删除操作较多的集合，但是适用于取值操作较多的...
java 哈希表和向量_Java语言中哈希表和使用方法
weixin_35866747的博客
02-13 268
哈希表，当看到这个词汇时我们想到的是什么呢，是不是手表之类的东西呢，如果是的，那你就错了，哈希表也称为散列表，是用来存储群体对象的集合类结构。下面IT培训网Java专家就来给大家详细介绍下什么是哈希表吧！什么是哈希表数组和向量都可以存储对象，但对象的存储位置是随机的，也就是说对象本身与其存储位置之间没有必然的联系。当要查找一个对象时，只能以某种顺序(如顺序查找或二分查找)与各个元素进行比较，当数组...
数据结构之散列表（java）
weixin_43698993的博客
12-27 431
1、散列表的基本概念 （1）散列函数:一个把查找表中的关键字映射成该关键字对应的地址的函数，记为 Hash(key)=AddrHash(key)=AddrHash(key)=Addr(这里的地址可以是数组下标、索引或内存地址等)。   散列函数可能会把两个或两个以上的不同关键字映射到同一地址，称这种情况为冲突，这些发生碰撞的不同关键字称为同义词。 （2）散列表:根据关键字而直接进行访问的数据结构。也就是说，散列表建立了关键字和存储地址之间的一种直接映射关系。   理想情况下，对散列表进行查找的时间复杂度为O
Java：散列表（Hash）
qq_48510607的博客
05-03 1470
可以将HashMap(散列表)理解为Python中的字典，一个键对应一个值，键是唯一的，如果键重复，后输入的键对应的值会覆盖前面的值。 import java.util.HashMap; import java.util.Scanner; public class Main { private HashMap<Integer, String> coinnames = new HashMap<Integer, String>(); //必须Integer,int报错,容器中的数
【Java数据结构】哈希表详解
耀的博客
12-30 1730
哈希表详解
java数据结构和算法(哈希表)
蒙奇D许的博客
10-02 1814
什么是哈希表？ 哈希表是一种数据结构，提供快速的插入和查找操作。 优点： 插入、查找、删除的时间级为O(1)； 数据项占哈希表长的一半，或者三分之二时，哈希表的性能最好。 缺点： 基于数组，数组创建后难于扩展，某些哈希表被基本填满时性能下降的非常严重；没有一种简单的方法可以以任何一种顺序（如从小到大）遍历整个数据项； 用途： 不需要遍历数据并且可以提前预
二叉搜索树与哈希表解析.pptx.pptx
12-19
这份PPT详细介绍了二叉搜索树和哈希表在Java语言中的实现，适合对这两种数据结构有深入理解的需求者学习。无论是作为基础数据结构的掌握，还是在实际编程项目中优化数据存储和查找性能，理解和掌握这些概念都是至关...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值