数据结构与算法第7章：Hash表

最新推荐文章于 2022-08-30 16:49:46 发布
最新推荐文章于 2022-08-30 16:49:46 发布
阅读量333 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 链表 算法 数据结构 hash hashmap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/javaambition/article/details/119394591
版权

数据结构与算法：Hash表

谷歌上机题

google 公司的一个上机题:
有一个公司，当有新的员工来报道时,要求将该员工的信息加入(id, 性别, 年龄,住址…)，当输入该员工的 id 时，要求查找到该员工的所有信息 要求：不使用数据库，尽量节省内存，速度越快越好 => 哈希表(散列)

Hash表介绍

散列表（Hash table， 也叫哈希表(对照java的HashMap)

  • 它通过把关键码值映射到表中一个位置来访问记录， 以加快查找的速度。 这个映射函数叫做散列函数， 存放记录的数组叫做散列表。
  • 实现思路
    根据对象的 hashCode 值，找到对应的数组下标，其实就是找到存储对象的链表
    在这里插入图片描述

Hash表作用

  • 缓存
  • 快速定位查找
    在这里插入图片描述

代码实现

员工emp。也就是每一个链表节点

  //头指针，执行第一个emp，因为我们这个链表的head是指向第一个Emp
    //表示员工
    static class Emp {
        public int id;
        public String name;
        public Emp next;

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

链表

//创建EmpLinkedList，表示链表
    static class EmpLikendList {

        private Emp head;

        //添加emp到链表
        //1.假定，当添加emp时，id是自增长的，即id的分配总是从小到大。因此将emp直接加入链表尾部
        public void addEmp(Emp emp) {
            //如果是添加第一个emp
            if (head == null) {
                head = emp;
                return;
            }
            Emp temp = head;
            while (true) {
                if (temp.next == null) {
                    //找到链表最后了
                    break;
                }
                temp = temp.next;
            }
            //退出循环时证明找到了链表最后一位，将next指向emp即可
            temp.next = emp;
        }

        //遍历emp链表
        public void listEmp() {
            if (head == null) {
                System.out.println("emp链表为空~");
                return;
            }
            Emp temp = head;
            while (true) {
                System.out.println("id:" + temp.id + "---name:" + temp.name);
                if (temp.next == null) {
                    break;
                }
                temp = temp.next;
            }

        }

        //按id查找。如果找到返回emp，否则返回null
        public Emp findByEmpId(int id){
            if (head == null){
                //链表空
                return null;
            }
            Emp temp = head;
            while (temp != null){
                if (temp.id == id){
                    //找到了
                    break;
                }
                temp = temp.next;
            }
            return temp;
        }

        //按id删除。
        public void delById(int id){
            if (head == null){
                System.out.println("链表为空~");
                return;
            }
            //因为该链表设计时并无头节点，第一个节点就是员工信息。所以要判断id=链表第一个员工时
            if (head.id == id){
                //此处采用移花接木。直接让第一个元素的id，name等于第二个元素
                if (head.next == null){
                    //链表就这一个员工,链表置空即可
                    head = null;
                }else {
                    //链表还有其他员工，但是要删除链表首个员工
                    Emp temp = head.next;
                    head.id = temp.id;
                    head.name = temp.name;
                    head.next = temp.next;
                }
                return;
            }
            //要删除的不是头节点,只需找到要删除元素的上一节点即可
            //是否找到
            boolean flag = false;
            Emp temp = head;
            while (true){
                if (temp.next == null){
                    //找到了最后
                    break;
                }
                if (temp.next.id == id){
                    flag = true;
                    break;
                }
                temp = temp.next;
            }
            //判断是否找到了要删除的员工
            if (flag){
                temp.next = temp.next.next;
            }else {
                System.out.println("未找到要删除的员工=>id:"+id);
            }
        }
    }

Hash表，多个链表组成的数组

 //创建hash表管理emp链表
    static class HashTable {
        private EmpLikendList[] empLikendLists;
        //表示共有多少条链表
        private int size;

        //构造器
        public HashTable(int size) {
            this.size = size;
            //初始化empLikendLists
            empLikendLists = new EmpLikendList[size];
            //这里初始化完成还必须实例化，不然数组每个元素为null。
            for (int i = 0; i < empLikendLists.length; i++) {
                empLikendLists[i] = new EmpLikendList();
            }
        }

        //添加emp
        public void add(Emp emp) {
            //根据empId，计算emp应该放哪条链表
            int hash = getHash(emp.id);
            //将emp添加到链表尾部
            empLikendLists[hash].addEmp(emp);
        }

        //遍历hash表
        public void listHashTable() {
            for (int i = 0; i < size; i++) {
                System.out.println("=====第" + (i + 1) + "个链表=====");
                empLikendLists[i].listEmp();
            }
        }

        //按id查找
        public void findById(int id){
            //先计算出hash找到所在数组哪个位置也就是说在哪个链表
            int hash = getHash(id);
            Emp emp = empLikendLists[hash].findByEmpId(id);
            if (emp == null){
                System.out.println("未找到id为:"+id+"的员工");
            }else {
                System.out.println("id:" + emp.id + "---name:" + emp.name);
            }
        }

        //按id删除员工
        public void delById(int id){
            int hash = getHash(id);
            empLikendLists[hash].delById(id);
        }


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

    }

完整代码

package com.ghl.hash;

import java.util.Scanner;

/**
 * <b>Function: </b> todo
 *
 * @program: HashTableDemo
 * @Package: com.ghl.hash
 * @author: GuoHeLong
 * @date: 2021/08/02
 * @version: 1.0
 * @Copyright: 2021 www.g1info.com Inc. All rights reserved.
 * 
 * hash表demo
 */
public class HashTableDemo {
    public static void main(String[] args) {
        HashTable table = new HashTable(6);
        String opera = "";
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.println("add:添加员工");
            System.out.println("list:显示");
            System.out.println("find:查找");
            System.out.println("del:id");
            System.out.println("exit:退出");
            opera = scanner.next();
            switch (opera) {
                case "add":
                    System.out.println("输入id");
                    int id = scanner.nextInt();
                    System.out.println("输入name");
                    String name = scanner.next();
                    //创建员工
                    Emp emp = new Emp(id, name);
                    table.add(emp);
                    break;
                case "list":
                    table.listHashTable();
                    break;
                case "find":
                    System.out.println("输入要查找的员工id");
                    int findId = scanner.nextInt();
                    table.findById(findId);
                    break;
                case "del":
                    System.out.println("输入要删除的员工id");
                    int delId = scanner.nextInt();
                    table.delById(delId);
                    break;
                default:
                    scanner.close();
                    System.exit(0);
            }
        }
    }

    //创建hash表管理emp链表
    static class HashTable {
        private EmpLikendList[] empLikendLists;
        //表示共有多少条链表
        private int size;

        //构造器
        public HashTable(int size) {
            this.size = size;
            //初始化empLikendLists
            empLikendLists = new EmpLikendList[size];
            //这里初始化完成还必须实例化，不然数组每个元素为null。
            for (int i = 0; i < empLikendLists.length; i++) {
                empLikendLists[i] = new EmpLikendList();
            }
        }

        //添加emp
        public void add(Emp emp) {
            //根据empId，计算emp应该放哪条链表
            int hash = getHash(emp.id);
            //将emp添加到链表尾部
            empLikendLists[hash].addEmp(emp);
        }

        //遍历hash表
        public void listHashTable() {
            for (int i = 0; i < size; i++) {
                System.out.println("=====第" + (i + 1) + "个链表=====");
                empLikendLists[i].listEmp();
            }
        }

        //按id查找
        public void findById(int id){
            //先计算出hash找到所在数组哪个位置也就是说在哪个链表
            int hash = getHash(id);
            Emp emp = empLikendLists[hash].findByEmpId(id);
            if (emp == null){
                System.out.println("未找到id为:"+id+"的员工");
            }else {
                System.out.println("id:" + emp.id + "---name:" + emp.name);
            }
        }

        //按id删除员工
        public void delById(int id){
            int hash = getHash(id);
            empLikendLists[hash].delById(id);
        }


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

    }


    //创建EmpLinkedList，表示链表
    static class EmpLikendList {

        private Emp head;

        //添加emp到链表
        //1.假定，当添加emp时，id是自增长的，即id的分配总是从小到大。因此将emp直接加入链表尾部
        public void addEmp(Emp emp) {
            //如果是添加第一个emp
            if (head == null) {
                head = emp;
                return;
            }
            Emp temp = head;
            while (true) {
                if (temp.next == null) {
                    //找到链表最后了
                    break;
                }
                temp = temp.next;
            }
            //退出循环时证明找到了链表最后一位，将next指向emp即可
            temp.next = emp;
        }

        //遍历emp链表
        public void listEmp() {
            if (head == null) {
                System.out.println("emp链表为空~");
                return;
            }
            Emp temp = head;
            while (true) {
                System.out.println("id:" + temp.id + "---name:" + temp.name);
                if (temp.next == null) {
                    break;
                }
                temp = temp.next;
            }

        }

        //按id查找。如果找到返回emp，否则返回null
        public Emp findByEmpId(int id){
            if (head == null){
                //链表空
                return null;
            }
            Emp temp = head;
            while (temp != null){
                if (temp.id == id){
                    //找到了
                    break;
                }
                temp = temp.next;
            }
            return temp;
        }

        //按id删除。
        public void delById(int id){
            if (head == null){
                System.out.println("链表为空~");
                return;
            }
            //因为该链表设计时并无头节点，第一个节点就是员工信息。所以要判断id=链表第一个员工时
            if (head.id == id){
                //此处采用移花接木。直接让第一个元素的id，name等于第二个元素
                if (head.next == null){
                    //链表就这一个员工,链表置空即可
                    head = null;
                }else {
                    //链表还有其他员工，但是要删除链表首个员工
                    Emp temp = head.next;
                    head.id = temp.id;
                    head.name = temp.name;
                    head.next = temp.next;
                }
                return;
            }
            //要删除的不是头节点,只需找到要删除元素的上一节点即可
            //是否找到
            boolean flag = false;
            Emp temp = head;
            while (true){
                if (temp.next == null){
                    //找到了最后
                    break;
                }
                if (temp.next.id == id){
                    flag = true;
                    break;
                }
                temp = temp.next;
            }
            //判断是否找到了要删除的员工
            if (flag){
                temp.next = temp.next.next;
            }else {
                System.out.println("未找到要删除的员工=>id:"+id);
            }
        }
    }

    //头指针，执行第一个emp，因为我们这个链表的head是指向第一个Emp
    //表示员工
    static class Emp {
        public int id;
        public String name;
        public Emp next;

        public Emp(int id, String name) {
            super();
            this.id = id;
            this.name = name;
        }
    }
}
觅风丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
(王道408考研数据结构)第七章查找-第四节：哈希表（基本概念及其操作）
快乐江湖的博客
12-01 2330
文章目录一：哈希表基本概念（1）哈希表（2）建立一个简单的哈希表（快速入门以及相关术语）（3）ASL计算二：常见哈希函数（1）直接定址法(常考)_{(常考)}(常考)​（2）除留余数法(常考)_{(常考)}(常考)​（3）平方取中法(了解)_{(了解)}(了解)​（4）数字分析法(了解)_{(了解)}(了解)​（5）折叠法(了解)_{(了解)}(了解)​（6）随机数法(了解)_{(了解)}(了解)​三：解决Hash冲突（1）闭散列（开放定址法）A：线性探测法B：二次探测法（2）开散列（链地址法） 一：哈希表
常用哈希函数结构 数据结构
05-07
目前比较有名的哈希函数 C语言 数据结构
[数据结构与算法]第9章 哈希表
qq_43115606的博客
02-06 3484
文章目录9.1 哈希表的基本介绍9.2 google公司的一个上机题: 9.1 哈希表的基本介绍 散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 9.2 google公司的一个上机题: 有一个公司,当有新...
java数据结构 第9章--哈希表
学无止境,勤则可达；志存高远,恒亦能成！
04-14 323
文章目录9.1 哈希表(散列)-Google 上机题9.2 哈希表的基本介绍9.3 google 公司的一个上机题:4）思路分析并画出示意图5）代码实现6）运行结果【学习笔记】【学习资料】 9.1 哈希表(散列)-Google 上机题 看一个实际需求，google 公司的一个上机题: 有一个公司,当有新的员工来报道时,要求将该员工的信息加入(id,性别,年龄,住址…),当输入该员工的id 时,要求查 找到该员工的所有信息. 要求: 不使用数据库,尽量节省内存,速度越快越好=>哈希表(散列
Chapter 02数据结构与算法——哈希表
好一个区块链
05-15 203
1 哈希表概述 哈希表是一种使用哈希函数组织数据，以支持快速插入和搜索的数据结构。 2 哈希表类型 哈希集合：集合数据结构的实现之一，用于存储非重复值。 哈希映射：映射数据结构的实现之一，用于存储(key, value)键值对。 3 哈希表原理 哈希表的关键思想是使用哈希函数将键映射到存储桶。 更确切地说， 当我们插入一个新的键时，哈希函数将决定该键应该分配到哪个桶中，并将该键存储在相应的桶中； 当我们想要搜索一个键时，哈希表将使用相同的哈希函数来查找对应的桶，并只在特定的桶中进行搜索。 4 哈希表算法
[数据结构 - 第8章] 查找之哈希表概念
weixin_30432007的博客
09-20 470
一、什么是哈希表？ 散列技术是在记录的存储位置和它的关键字之间建立一个确定的对应关系 f，使得每个关键字 key 对应一个存储位置 f(key）。 我们把这种对应关系 f 称为哈希函数（也叫散列函数）。采用散列技术将记录存储在一块连续的存储空间中，这块连续的存储空间称为哈希表（Hash table，也叫散列表）。关键字对应的记录存储位置我们称为散列地址。 整个散列过程其实就是两步： 插...
数据结构第七章查找(“查找”文档)共60张.pptx
12-02
在顺序查找过程中，我们从表的第一个元素开始，逐个与给定值进行比较，直到找到匹配的元素或者遍历完整个表。优点是算法简单，但效率较低，平均查找长度为（n+1）/2，时间复杂度为O(n)，当数据量较大时，性能不佳。 ...
javalruleetcode-dsal:数据结构与算法个人整理
06-29
常见的数据结构实现 基本的线性结构： : 数组 ： 链表 ： 队列 基于链表实现队列、基于循环数组实现队列 ： 栈 ： 堆 ： 集合与映射 ：Hash 表 树形结构： ： 二分查找树 ： 平衡树 ： 红黑树 ： 线段树 ： 字典树 ...
最快的排序算法 计算机最快的算法-史上14个最快速算法：孩子的计算能力爆表！大脑堪比计算机！...，排序算法数据结构
04-07
选择排序算法也是一种简单的排序算法，它的工作原理是通过选择最小或最大元素，并将其与第一个元素交换，以达到排序的目的。选择排序算法的时间复杂度也为O(n^2)，因此它也适合小规模的数据排序。 3.插入排序算法 ...
第五章：查找-2021-11
08-03
本章内容主要涵盖了数据结构与算法中的查找技术，适用于计算机科学与技术学院的学生学习。查找是数据处理中的基础操作，它根据给定的值在数据集合中寻找相应记录或元素的过程。本章将深入探讨多种查找方法，包括...
哈希表------链表
10-29
哈希表--链表 哈希表--链表 哈希表--链表 哈希表--链表哈希表--链表 哈希表--链表哈希表--链表 哈希表--链表哈希表--链表 哈希表--链表哈希表--链表 哈希表--链表
广东工业大学数据结构anyview代码第二章
01-25
广东工业大学的数据结构课程是计算机科学与技术专业的重要基础课程，主要涵盖了数据的组织、存储和操作方法。在第二章的学习中，通常会涉及到一系列的核心概念和算法，这些内容对于理解和解决实际编程问题至关重要。...
数据结构与算法（第九章 哈希表）
qq_45087487的博客
05-13 172
9.1哈希表（散列）-Google上机题 （1）看一个实际需求，google 公司的一个上机题: （2）有一个公司,当有新的员工来报道时,要求将该员工的信息加入(id,性别,年龄,住址…),当输入该员工的 id 时,要求查找到该员工的 所有信息. （3）要求: 不使用数据库,尽量节省内存,速度越快越好=>哈希表(散列) 9.2哈希表的基本介绍 散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录
数据结构和算法(第九章哈希表)
m0_50507927的博客
03-10 3630
文章目录前言一、哈希表的基本介绍二、哈希表的实际应用场景三、使用哈希表来管理雇员信息1.分析2.表示一个雇员的代码3.EmpLinkedList,表示链表(链表里面存放数据)的代码4.创建哈希表，用来管理多条链表的代码5.哈希表小练总结 前言 提示：以下是本篇文章正文内容，下面案例可供参考 一、哈希表的基本介绍 二、哈希表的实际应用场景 三、使用哈希表来管理雇员信息 1.分析 2.表示一个雇员的代码 代码如下（示例）： class Emp{ public int id; publ
数据结构之哈希表
weixin_47706805的博客
08-30 219
首先明确哈希表也是种数据结构，本质上是储存键值对的数组。
数据结构-散列表 哈希表
charlie_heng的专栏
03-02 445
最近在看《数据结构与算法》，看到散列表这一章，之前一直听说过哈希表，但是一直不知道它怎么解决冲突的问题，现在看完之后才发现原来是用邻接表来解决冲突的问题 下面是具体的实现
hash表浅析
gxjlt的博客
04-06 114
散列表(也叫哈希表)，是根据关键码值直接进行访问的数据结构，也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 我觉得这个解释太含糊，想要整明白哈希表，那就得明白哈希表到底有什么样的优势。 数据结构中，有个时间算法复杂度O(n)的概念来衡量某种算法在时间效率上的优劣。哈希表的理想算法复杂度为O(1)，...
关于哈希表和数据结构的一点随笔
云中寻雾的博客
08-05 661
1. 哈希法的概念或原理：   思想是通过一定的手段以达到能通过关键字K直接找到存储以关键字为K的K-V键值对，这个手段就是哈希函数：(便于计算，地址分布均匀，冲突少)，而构造出的结果是一张哈希表。 2. 哈希函数的构造方法： 1、直接寻址法 2、取模法 3、数字分析法 4、折叠法 5、平方取中法 6、除留余数法 7、随机数法 8、单旋转法  3. 处理冲突的方法 原因：因为无论不同的构...
[数据结构与算法-理论] Hash表
sougou_1323的博客
01-17 391
文章目录1. 概念1） Hash表2） Hash函数2. Hash冲突1） 必然发生Hash冲突2） Hash函数的要求3） 解决Hash冲突（1） 开放寻址法1. 线性探测2. 二次探测3. 双重散列（哈希）（2） 链表法3. Hash表扩容 1. 概念 1） Hash表 Hash表也叫哈希表、散列表，（我的理解）它是一种特殊的数组。数组是支持随机访问的一种数据结构，我们可以根据下表直接访问内容...
数据结构与算法重要知识点
最新发布
08-25
5. 哈希表(Hash Table)：根据键(key)直接访问值(value)的数据结构，通过散列函数将键映射到特定的存储位置。 6. 树(Tree)：一种非线性数据结构，由节点和边组成，每个节点可以有多个子节点。 7. 图(Graph)：由节点...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值