哈希表

最新推荐文章于 2023-06-04 19:55:34 发布
最新推荐文章于 2023-06-04 19:55:34 发布
阅读量147 收藏
点赞数
分类专栏： Java数据结构与算法 文章标签： java 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43618030/article/details/104347413
版权

哈希表的基本介绍

在这里插入图片描述

哈希表流程图

在这里插入图片描述

哈希表（散列）——Google上机题

在这里插入图片描述

哈希表管理雇员思路分析

在这里插入图片描述

代码

表示一个雇员

package com.hashtab;

public class HashTabDemo {
    public static void main(String[] args) {

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

	//构造方法
    public Emp(int id, String name) {
        this.id = id;
        this.name = name;
    }
}

创建一个EmpLinkedList，表示链表——创建一个头指针

//创建一个EmpLinkedList，表示链表
class EmpLinkedList {
    //头指针，执行第一个Emp，因此我们这个链表的head是直接指向第一个Emp
    private Emp head;//默认值为null

}

添加雇员到链表

    //添加雇员到链表
    //说明
    //1.假定，当添加雇员时，id是自增长，即id的分配总是从小到大
    // 因此我们将该雇员直接加入到本链表的最后即可
    public void add(Emp emp){

    }

添加雇员到链表-如果是添加第一个雇员

    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(){

    }

遍历链表的雇员信息-说明链表为空

    //遍历链表的雇员信息
    public void list() {
        if (head == null) {
            //说明链表为空
            System.out.println("链表为空");
            return;
        }

遍历链表的雇员信息-当前的链表信息

        System.out.println("当前的链表信息为");
        Emp curEmp = head;//辅助指针
        while (true) {
            System.out.println("=> id=%id name=%s\t, curEmp.id, cueEmp.name");
            if (curEmp.next == null){
                //说明curEmp已经是最后结点
                break;
            }
            curEmp = curEmp.next;//后移，遍历
        }
        System.out.println();

创建HashTab 管理多条链表

//创建HashTab 管理多条链表
class HashTab {
    private EmpLinkedList[] empLinkedListsArray;

}

创建HashTab 管理多条链表-构造器

    //构造器
    public HashTab(int size) {
        //初始化empLinkedListsArray
        empLinkedListsArray = new EmpLinkedList[size];
    }

缩写散列函数，使用一个简单取模法

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

    //构造器
    public HashTab(int size) {
        this.size = size;
        //初始化empLinkedListsArray
        empLinkedListsArray = new EmpLinkedList[size];
    }

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

创建HashTab 管理多条链表-添加雇员-根据员工的id，得到该员工应当添加到那条链表

    //添加雇员
    public void add(Emp emp) {
        //根据员工的id，得到该员工应当添加到那条链表
        int empLinkedListNo=hashFun(emp.id);
    }

创建HashTab 管理多条链表-添加雇员-将emp添加到对应链表中

    public void add(Emp emp) {
        //根据员工的id，得到该员工应当添加到那条链表
        int empLinkedListNo=hashFun(emp.id);
        //将emp添加到对应链表中
        empLinkedListsArray[empLinkedListNo].add(emp);

创建HashTab 管理多条链表-遍历所有的链表,遍历hashTab

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

创建哈希表

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("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;
                default:
                    break;
            }

写一个简单的菜单-查看

              case "list":
                    hashTab.list();
                    break;

写一个简单的菜单-退出

                case "exit":
                    scanner.close();
                    System.exit(0);

创建HashTab 管理多条链表-添加雇员-重点：不要分别初始化每个链表

        //重点：不要分别初始化每个链表
        for (int i = 0; i < size; i++) {
            empLinkedListsArray[i] = new EmpLinkedList();
        }

修改bug

    //遍历所有的链表,遍历hashTab
    public void list() {
        for (int i = 0; i < size; i++) {
            empLinkedListsArray[i].list();
            empLinkedListsArray[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;

创建HashTab 管理多条链表-根据id查找雇员

    //根据id查找雇员
    //如果查找到，就返回Emp，如果没有找到，就返回null
    public Emp findEmpById(int id) {

    }

创建HashTab 管理多条链表-根据id查找雇员-判断链表是否为空-链表为空

        //判断链表是否为空
        if (head == null) {
            System.out.println("链表为空");
            return null;
        }

创建HashTab 管理多条链表-根据id查找雇员-判断链表是否为空-辅助指针

       //辅助指针
        Emp curEmp = head;
        while (true) {
            if (curEmp.id == id) {//找到
                //这时curEmp就指向要查找的雇员
                break;
            }
            //退出
            if (curEmp.next == null) {
                //说明遍历当前链表没有找到该雇员
                curEmp = null;
            }
            curEmp = curEmp.next;//以后
        }
        return curEmp;

创建HashTab 管理多条链表-根据输入的id查找雇员-使用散列函数确定那条链表查找

    //根据输入的id查找雇员
    public void findEmpById(int id) {
        //使用散列函数确定那条链表查找
        int empLinkedListNo = hashFun(id);
        Emp emp = empLinkedListsArray[empLinkedListNo].findEmpById(id);

    }

创建HashTab 管理多条链表-根据输入的id查找雇员-判断下有没有找到

        if (emp != null) {//找到
              System.out.printf("在第%d条链表中找到雇员id = %d\n", (empLinkedListNo + 1), id);
        } else {
            System.out.println("在哈希链表中，没有找到该雇员");
        }

写一个简单的菜单-查找雇员

 while (true) {
            System.out.println("add: 添加雇员");
            System.out.println("list: 显示雇员");
            System.out.println("find: 查找雇员");
            System.out.println("exit: 退出雇员");

            key = scanner.next();

                case "find":
                    System.out.println("输入要查找的id");
                    id = scanner.nextInt();
                    hashTab.findEmpById(id);
                    break;

            if (curEmp.next == null) {
                //说明遍历当前链表没有找到该雇员
                curEmp = null;
                break;

完整代码

package com.hashtab;

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("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[] empLinkedListsArray;
    private int size;   //表示有多少条链表

    //构造器
    public HashTab(int size) {
        this.size = size;
        //初始化empLinkedListsArray
        empLinkedListsArray = new EmpLinkedList[size];
        //重点：不要分别初始化每个链表
        for (int i = 0; i < size; i++) {
            empLinkedListsArray[i] = new EmpLinkedList();
        }
    }

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

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

    //根据输入的id查找雇员
    public void findEmpById(int id) {
        //使用散列函数确定那条链表查找
        int empLinkedListNo = hashFun(id);
        Emp emp = empLinkedListsArray[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 Emp {
    public int id;
    public String name;
    public Emp next;//默认为null

    //构造方法
    public Emp(int id, String name) {
        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) {//找到
                //这时curEmp就指向要查找的雇员
                break;
            }
            //退出
            if (curEmp.next == null) {
                //说明遍历当前链表没有找到该雇员
                curEmp = null;
                break;
            }
            curEmp = curEmp.next;//以后
        }
        return curEmp;
    }
}
Dkui
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图解数据结构(04) -- 哈希表
姜皓的博客
12-30 2457
哈希表1、什么是哈希表2、哈希函数哈希函数的实现3、哈希表的读写操作写操作（put）读操作（get）扩容（resize）4、总结 1、什么是哈希表 哈希表（hash table），这种数据结构提供了键（Key）和值 （Value）的映射关系；只要给出一个Key，就可以高效查找到它所匹配的Value，时间复杂度接近于O(1) 2、哈希函数 散列表在本质上也是一个数组，可是数组只能根据下标，像a[0...
HashMap流程图
rlk512974883的博客
10-22 754
HashMap源码流程图
大雄哆啦的博客
08-27 384
jdk8版本 jdk7版本
java8-hashMap流程图
风中追风
05-20 395
哈希表算法实现
热门推荐
jdh99的专栏
01-10 3万+
哈希表算法实现 本文博客链接:http://blog.csdn.net/jdh99,作者:jdh,转载请注明. 环境： 主机:WINXP 开发环境:MINGW 说明: 本程序建立的哈希表示意图: 哈希函数为对哈希表长取余 源代码: /**********************************************
哈希表实验C语言版实现
09-05
哈希表是一种高效的数据结构，它通过特定的哈希函数将键（Key）映射到一个固定大小的数组中，从而实现快速的插入、查找和删除操作。在本实验中，哈希表的C语言实现主要涉及以下几个核心知识点： 1. **哈希表的基本...
哈希表课程设计数据结构实验报告——哈希表设计
07-05
哈希表课程设计数据结构实验报告——哈希表设计 针对某个集体中的人名设计一个哈希表，使得平均查找长度不超过R，完成相应的建立和查表程序. 1.2 人名为汉语拼音形式，最长不超过18个字符(如：庄双双 ...
哈希表哈希表哈希表.zip
最新发布
05-29
哈希表，也被称为散列表，是计算机科学中一种高效的数据结构，用于存储和检索数据。它通过将关键字（key）映射到一个特定的位置来实现快速访问，这个位置称为哈希码或哈希值。哈希表的核心原理是利用哈希函数将...
哈希表的设计与实现【课程设计】
06-23
哈希表的设计与实现课程设计 问题描述：针对某个单位电话号码簿，设计一个哈希表，并完成相应的建表和查表程序。 基本要求：设每个记录有下列数据项：电话号码、用户名、住址。从键盘输入各记录，以用户名为关键字...
图文并茂深入学习哈希表 (上)
雪月清的博客
03-03 884
目录 一、哈希表简介 1.哈希冲突 2.jdk1.8的哈希冲突解决方案 二、哈希函数 1.哈希表中哈希函数的实现步骤： 2.如何生成key的哈希值？ 三、总结： 一、哈希表简介 哈希表也称为散列表 底层是由数组+单链表+红黑树实现 添加、搜索、删除的流程 （1）利用hash函数生成key对应的数组索引 index O（1） （2）根据index操作定位数组元素 O（1） 哈希表采用 空间换时间的思路 1. 哈希冲突 2个不同的key，经过哈希函数计算出相.
数据结构算法之哈希表原理图解
LYR1994的博客
04-23 805
hash表建立，查找，详解
老五的作坊
03-22 1万+
散列表（Hash table，也叫哈希表），是根据关键字（Key value）而直接访问在内存存储位置的数据结构。也就是说，它通过计算一个关于键值的函数，将所需查询的数据映射到表中一个位置来访问记录，这加快了查找速度。这个映射函数称做散列函数，存放记录的数组称做散列表。 应用场景 任何一个问题，当选择数据结构的时候一般只有有限的几个选择：数组、链表、二叉树（绝大多数的场景下都是使用二叉
算法数据结构基础——哈希表（Hash Table）
白话机器学习
06-04 2万+
哈希表（Hash Table）：也叫做散列表。是根据关键码值（Key Value）直接进行访问的数据结构。哈希表通过「键key」和「映射函数Hash(key)」计算出对应的「值value」，把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做「哈希函数（散列函数）」，存放记录的数组叫做「哈希表（散列表）」。哈希表的关键思想是使用哈希函数，将键key映射到对应表的某个区块中。向哈希表中插入一个关键码值：哈希函数决定该关键字的对应值应该存放到表中的哪个区块，并将对应值存放到该区块中。
哈希表（带图解）
xu_haopeng的博客
11-28 5326
哈希表 常见的搜索方式： 1、顺序搜索——O(N) 2、二分搜索——O(log₂N) 3、搜索树结构中的查找：二叉树搜索——O(N)，AVL——O(log₂N)，红黑树——O(log₂N) 以上都需要比较，那有没有不需要比较就能查找的方法呢？ 概念 顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O(log₂N)，搜索的效率取决于搜索过程中元素的比较次数。 理想的搜索方法：可以不经过任何比较
哈希结构（图文详解）【哈希表，哈希桶，位图，布隆过滤器】
AllenSquirrel
05-29 5679
哈希结构 哈希概念 常见的K-V结构，实现了元素关键码与元素值的映射关系，但没有实现元素关键值与元素存储位置的映射关系，在遍历过程中，一般的顺序表或搜索二叉树要进行关键值的多次比较，其中顺序表的时间复杂度为O(n),二叉搜索树的时间复杂度O(lgn) 对此希望找到一种理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。 如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素 哈希
Hash表分析以及Java实现
JAVA_MZD的博客
11-29 264
       这篇博客主要探讨Hash表中的一些原理/概念，及根据这些原理/概念，自己设计一个用来存放/查找数据的Hash表，并且与JDK中的HashMap类进行比较。 我们分一下七个步骤来进行。  一。    Hash表概念 二 .      Hash构造函数的方法，及适用范围 三.       Hash处理冲突方法，各自特征 ...
哈希表的存储原理（流程）
weixin_45397671的博客
07-20 1254
（1）调用hashCode()方法计算Hash码值 （2）根据y=k(x)这样的函数计算存储位置 ——x就是哈希码值，y就是存储位置 （3）如果位置上没有元素，则将元素存储 （4）如果该位置上有元素，则需调用equal()方法比较内容是否相同，若相同则不再存储，不相同则存储在新的链表。 ...
哈希表的构造方法
fsfsfsdfsdfdr的博客
09-06 5794
哈希表的构造方法：             （1）、数字分析法：事先知道关键字的集合，且每个关键字的位数比哈希表的地址码位数多时，可以从关键字中选出分布比较均匀的若干位，构成哈希地址。             （2）、平方取中法：当无法确定关键字中哪几位分布比较均匀时，可以先求出关键字的平方值的中间几位作为哈希地址             （3）、分段叠加法：按哈希表的地址位数将关键字分成位...
哈希表 javascript
12-12
在JavaScript中，哈希表可以通过对象（Object）来实现。对象的属性名就是哈希表中的键，属性值就是哈希表中的值。以下是一个简单的哈希表的实现： 1. 定义一个HashTable类，包含以下方法： ```javascript class ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值