【JAVA】手写一个简易的动态哈希表

已于 2024-04-30 00:08:10 修改
阅读量658 收藏 8
点赞数 18
文章标签： 散列表 java 哈希算法
于 2023-12-25 11:47:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74152086/article/details/135194330
版权

文章目录

前言

今天学习的内容是哈希表，然后通过手写一个简易的动态哈希表来检验自己对于哈希表的理解。

一、分析哈希表的组成

通过学习哈希表，我们可以知道，哈希表本质上就是根据key值寻找对应的value值的数据结构。key到value的过程中需要一个散列函数来联系两个值，而散列函数的好坏很大程度上决定了冲突发生的次数。
在本文中，我们使用链地址法解决冲突问题。
因此我们的设计是：动态数组+链表+哈希函数

二、实现非动态哈希表

1.数组定义+链表定义

数组定义代码如下（示例）：

 public int initiatesize = 16;//定义初始容量
 public int length =initiatesize;//如果没有发生二次装载，就等于初始大小为16
 public int buksize=0;//这个代表现在哈希表里的元素个数
 public list[] linkArr=new list[length];//数组
 public void initialize(int lenth){//初始化
        //每一个数组里存储一个链表头结点
        buksize=0;
        for(int i = 0; i< lenth; i++){
            linkArr[i]=new list();
            linkArr[i].size=0;
        }
    }

链表定义与基本功能实现代码（示例如下）：
这个地方的基本功能大家可以详细看一看，以便理解后面的代码

class node{
    public int data;
    public  Object key;
    public node next;
    public node(int data,Object key) //数据初始化
    {
        this.data=data;
        this.key=key;
    }
    public node(){}//方法重写
}
class list {
    public node root;//根结点
    public node last;//尾结点
    public int size=0;
    public list() {
        root = new node();
    }

    //在尾部增加元素
    public int add(int data,Object key,int buksize) {
        node temp = new node(data,key);
        node head = root.next;//头结点
        node p=head;
        int flag=0;
        if (head == null) {
            root.next = temp;//开辟的新空间作为头
            last = temp;
            buksize++;
        } else {
            while(p!=null)
            {//如果两次输入同一个key不同的value我们就用后面的value替换前面的
                if((key!=null&&key.equals(p.key)))
                {
                    p.data=data;
                    flag=1;
                }
                p=p.next;
            }
            if(flag==0)
            {
                buksize++;
                last.next = temp;
                last = temp;
            }
        }
        size++;
        return buksize;
    }

    //返回指定位置的节点
    public int getnode(Object key) {
        node p = root.next;
        for (int i = 0;; i++) {
            if(p==null)
                break;
            else if((key!=null&&key.equals(p.key)))
                return p.data;
            else if(p.key==null&&key==null)//这个是为了读取key值为null时对应的value
                return p.data;
            p=p.next;
        }
        return -1;
    }
    public int getSize(){
        return size;
    }
    //输出链表
    public void printf(int n) {
        node p = root.next;
        for (int i = 0; i < n; i++) {
            if(p==null)
            {
                //System.out.println("null!");
                break;
            }
            System.out.println("key:"+p.key+"  data:"+p.data);
            p = p.next;
        }
    }
}

2.哈希函数的设计

哈希函数设计代码如下（示例）：

//哈希函数
    public int hash(Object key,int lenth){
        int hashcode=key.hashCode();
        int index=hashcode%lenth;//取余数法
        //System.out.println(index+"+"+lenth);
        return Math.abs(index);//abs是取绝对值
    }

3.基本功能put与get

在实现这两个功能的时候都要注意这里的哈希表允许key为null的情况出现，所以多加一层判定讨论
以下是put功能代码示例：

public void put(Object key,int value,list[] linkArr){
        int index;
        if(key!=null)
        {
            index= hash(key,length);
            this.buksize=linkArr[index].add(value,key,buksize);
        }
        else//key为空的时候默认存放到linkArr[0]的链表后面
        {
            this.buksize=linkArr[0].add(value,key,buksize);
        }
    }

以下是get功能方法示例：

//获取元素
    public void get(Object key){
        if(key!=null)
        {
            int index = hash(key, length);
            System.out.println("value="+linkArr[index].getnode(key));
        }
        else
        {
            System.out.println("value="+linkArr[0].getnode(key));
        }
    }

三、修改为动态哈希表

1.装载因子与二次散列

在动态的设计上，我们采用的方式是引入装载因子来进行是否二次散列动态扩容的判断。
装载因子：反映了哈希表汇总元素填满的程度
二次装载：通常我们会选择将哈希表扩容为2倍，对原先的键值对进行二次散列以完成动态扩容

1）定义

    public int initiatesize = 16;//定义初始容量为16
    public int num=100;//现在需要放进的数量
    public int buksize=0;//目前哈希表里的元素个数
    public int length =initiatesize;//如果没有发生二次装载，就等于初始大小
    public float load=0.75f;//定义装载因子

2）存放时的处理
因为现在要建设动态哈希表，所以我们需要在put方法添加一行代码判断是否需要resize

public void put(Object key,int value,list[] linkArr){
        //加上对是否需要扩容的判断
        int index;
        if(buksize>=linkArr.length*load)
        {
            linkArr=resize() ;//二次装载
        }
        if(key!=null)
        {
            index= hash(key,length);
            this.buksize=linkArr[index].add(value,key,buksize);
        }
        else
        {
            this.buksize=linkArr[0].add(value,key,buksize);
        }
    }

3）resize扩容功能的实现
先将长度修改为两倍，创建一个新的数组并对新数组进行初始化；
再调用rehash函数调整原有键值对的位置；
最后将原来的数组指针修改为新数组，并返回原数组；

//扩容
    public  list[] resize()
    {
        length *=2;
        list[] newlinkArr = new list[length];
       // 对新数组的初始化
        for(int i = 0; i< length; i++)
            newlinkArr[i] = new list();
        reharsh(newlinkArr);
        System.out.println("完成 rehash");
        linkArr = newlinkArr;
       // System.out.println(linkArr.length);
        return linkArr;
    }

4）rehash功能的实现

//重新散列
    public void reharsh(list[] newlinkArr)
    {
        buksize=0;//更新现在的元素个数
        for(int i=0;i<linkArr.length;i++)
        {
            if(linkArr[i].root.next==null)
                continue;
            node temp =linkArr[i].root.next;
            while(temp!=null)
            {
                put(temp.key,temp.data,newlinkArr);
                //非空就将键值对都放进新数组里面
                temp=temp.next;
            }
        }
    }

现在一个动态的哈希表就完成了，我们可以自行控制输入数据的数量，哈希表的初始容量为16但是遇见超出装载因子的情况时，可以自行扩容。

四、主函数与所有代码

1.主函数

主函数这里为了方便测试，我直接使用了18,12的倍数输入，可能没有办法很好的反映哈希表的效果
然后就是添加了（null，5）对实现key为空时哈希表功能的检测
以及添加了（198,140）对实现key相同时哈希表覆盖功能的检测

 //主函数
    public static void main (String[] args)
    {
        HashMap hm = new HashMap();
        hm.initialize(hm.length);
        for(int i = 1; i< hm.num; i++){
            //System.out.println("put:"+"key:"+i*18+"  value:"+i*12);
            hm.put(i*18,i*12, hm.linkArr);
        }
        hm.put(198,140, hm.linkArr);//重叠就修改数据
        hm.put(null,5, hm.linkArr);//key值为空的数据
        for(int i = 0; i<hm.length; i++)
        {
            if(hm.linkArr[i]!=null) {
                System.out.println(i+":");
                hm.linkArr[i].printf(hm.linkArr.length);
            }
        }
        Object a=null;
        System.out.println("get key "+a +" :");
        hm.get(a);
        System.out.println("get key "+"198" +" :");
        hm.get(198);
    }

2.所有的代码

public class HashMap {
    public int initiatesize = 16;//定义初始容量为16
    public int num=32;//现在需要放进的数量
    public int buksize=0;
    public int length =initiatesize;//如果没有发生二次装载，就等于初始大小
    public float load=0.75f;//定义装载因子
    public list[] linkArr=new list[length];//数组
    public void initialize(int lenth){//初始化
        buksize=0;
        for(int i = 0; i< lenth; i++){
            linkArr[i]=new list();
            linkArr[i].size=0;
        }
    }
    //增加元素
    public void put(Object key,int value,list[] linkArr){
        //加上对是否需要扩容的判断
        int index;
        if(buksize>=linkArr.length*load)
        {
            linkArr=resize() ;//二次装载
        }
        if(key!=null)
        {
            index= hash(key,length);
            this.buksize=linkArr[index].add(value,key,buksize);
        }
        else
        {
            this.buksize=linkArr[0].add(value,key,buksize);
        }
    }
    //扩容
    public  list[] resize()
    {
        length *=2;
        list[] newlinkArr = new list[length];
       // initialize(lenth);
        for(int i = 0; i< length; i++)
            newlinkArr[i] = new list();
        reharsh(newlinkArr);
        System.out.println("完成 rehash");
        linkArr = newlinkArr;
       // System.out.println(linkArr.length);
        return linkArr;
    }
    //重新散列
    public void reharsh(list[] newlinkArr)
    {
        buksize=0;
        for(int i=0;i<linkArr.length;i++)
        {
            if(linkArr[i].root.next==null)
                continue;
            node temp =linkArr[i].root.next;
            while(temp!=null)
            {
                put(temp.key,temp.data,newlinkArr);
                temp=temp.next;
            }
        }
    }
    //获取元素
    public void get(Object key){
        if(key!=null)
        {
            int index = hash(key, length);
            System.out.println("value="+linkArr[index].getnode(key));
        }
        else
        {
            System.out.println("value="+linkArr[0].getnode(key));
        }
    }
    //散列函数
    public int hash(Object key,int lenth){
        int hashcode=key.hashCode();
        int index=hashcode%lenth;
        //System.out.println(index+"+"+lenth);
        return Math.abs(index);
    }
    //主函数
    public static void main (String[] args)
    {
        HashMap hm = new HashMap();
        hm.initialize(hm.length);
        for(int i = 1; i< hm.num; i++){
            //System.out.println("put:"+"key:"+i*18+"  value:"+i*12);
            hm.put(i*18,i*12, hm.linkArr);
        }
        hm.put(198,140, hm.linkArr);//重叠就修改数据
        hm.put(null,5, hm.linkArr);//key值为空的数据
        for(int i = 0; i<hm.length; i++)
        {
            if(hm.linkArr[i]!=null) {
                System.out.println(i+":");
                hm.linkArr[i].printf(hm.linkArr.length);
            }
        }
        Object a=null;
        System.out.println("get key "+a +" :");
        hm.get(a);
        System.out.println("get key "+"198" +" :");
        hm.get(198);
    }
}
class node{
    public int data;
    public  Object key;
    public node next;
    public node(int data,Object key) //数据初始化
    {
        this.data=data;
        this.key=key;
    }
    public node()//方法重写
    {

    }
}
class list {
    public node root;//根结点
    public node last;//尾结点
    public int size=0;
    public list() {
        root = new node();
    }

    //在尾部增加元素
    public int add(int data,Object key,int buksize) {
        node temp = new node(data,key);
        node head = root.next;//头结点
        node p=head;
        int flag=0;
        if (head == null) {
            root.next = temp;//开辟的新空间作为头
            last = temp;
            buksize++;
        } else {
            while(p!=null)
            {
                if((key!=null&&key.equals(p.key)))
                {
                    p.data=data;
                    flag=1;//重复替换完成
                }
                p=p.next;
            }
            if(flag==0)
            {
                buksize++;
                last.next = temp;
                last = temp;
            }
        }
        size++;
        return buksize;
    }

    //返回指定位置的节点
    public int getnode(Object key) {
        node p = root.next;
        for (int i = 0;; i++) {
            if(p==null)
                break;
            if((key!=null&&key.equals(p.key)))
                return p.data;
            if(p.key==null&&key==null)
                return p.data;
            p=p.next;
        }
        return -1;
    }
    public int getSize(){
        return size;
    }
    //输出函数
    public void printf(int n) {
        node p = root.next;
        for (int i = 0; i < n; i++) {
            if(p==null)
            {
                //System.out.println("null!");
                break;
            }
            System.out.println("key:"+p.key+"  data:"+p.data);
            p = p.next;
        }
    }
}

总结

以上就是今天要讲的内容，如果有什么问题欢迎评论区里指出。然后后面如果有时间我可能会再写一篇手写实现链表的一些功能的博客。

QZ_463
关注
  • 18
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
手写数据结构算法.zip
01-14
即一个有效的算法必须能在有限步骤内结束，并且对于给定的输入产生唯一的确定输出。 算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra...
algorithms:经典数据结构、算法、面试题的Java实现
06-25
《算法：经典数据结构、算法、面试题的Java实现》是一个专注于Java编程语言的数据结构与算法实践项目。这个项目旨在帮助开发者深入理解并熟练运用各种基础及进阶的数据结构和算法，同时也为求职者提供了丰富的面试...
数据结构——手动写一个哈希表
qq_48201696的博客
08-05 863
数据结构——哈希表 哈希表介绍 1、什么是哈希表？ 可以考虑这么一个情景： 现在某个学校为新生录入信息，新生们的学号为2001、2002、2003…这样的类型，现将其存储在一个数组中，现在要查找学号为2066的学生。 如果采用顺序查找的方法进行查找，它的执行过程是先从数组第一个位置出发，将2066与这个位置对应的关键字进行比较，直到找到那个与2066相等的位置返回，这次查找过程中，一共需要66次查找 而假设我们设定一个函数，h(学号) = 学号-2001,然后通过这个函数来定位2066这个学号对应在哪个
【LeetCode笔记】128. 最长连续序列（Java、哈希表、动态规划）
只能说希望每日一更
04-25 141
文章目录题目描述思路 & 代码变式题：返回答案数组 可恶。。居然碰到了周一面试没撕出最优复杂度的题 题目描述 难点在于时间复杂度O(n)，否则来个sort()还是很轻松的 思路 & 代码 一般来说，时间复杂度可以用空间复杂度来弥补：来选个数据结构吧！ 显而易见，哈希表！K - V ：数组元素 - 以该元素为端点的序列的最长值 状态转移方程：now = left + right + 1 最优子结构：left & right put(i ,now) 只是为了 contains
从0到1打牢算法基础之手写一个哈希表
Francis的博客
10-23 491
从0到1打牢算法基础之手写一个哈希表0.导语目的：手写实现一个哈希表，采用拉链法构建，每个hash(key)对应的是一个红黑树。看起来很简单，但可以学到很多东西。实现语言...
BBS.rar_bbs_bbs论坛Java源代码_java BBS_java b
09-23
【描述】"一个用Java编写的BBS源代码，和大家分享" 表明这是一个开源项目，作者或开发者愿意将其分享给其他开发者学习和研究。通过分析和学习这个源代码，开发者可以深入了解Java在构建Web应用程序，特别是BBS这类...
手写HashMap源码.rar
02-22
HashMap是Java编程语言中一个常用的集合类，它提供了一种高效、灵活的键值对存储方式。在面试过程中，尤其是2020年及以后的技术面试中，深入理解HashMap的实现原理成为了考察候选人基础技能的重要环节。本篇文章将...
Collections源码java-collections_analysis:手写spring（先）及java自带的集合框架源码分析（后）
05-19
通过对这些类的源码分析，我们可以了解到它们的内部结构，如链表的节点管理、数组的动态扩展、哈希映射的冲突解决策略等，这些都是Java集合框架的重要组成部分。 6. **自定义集合实现**： 学习Collections源码的...
Java内存模型
最新发布
weixin_44267758的博客
07-19 329
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 629
JVM-垃圾回收与内存分配
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 867
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
【Java算法】前缀和 下
2302_79806056的博客
07-18 914
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
【JAVA】相关程序组件
qq_44077764的博客
07-15 173
【JAVA】相关程序组件
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
liangzai215的专栏
07-15 512
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。
构建自动化的精粹：Gradle任务依赖性与执行顺序控制
liuxin33445566的博客
07-15 589
本文以"构建自动化的精粹：Gradle任务依赖性与执行顺序控制"为题，详细介绍了任务依赖性的重要性、基本配置、多个任务的依赖性、条件依赖性、错误处理、高级用法、多项目构建中的任务依赖性。随着Gradle的不断发展，我们可以预见到更多关于任务依赖性和构建自动化的高级特性的出现，这将进一步扩展Gradle的构建能力，满足更复杂的项目构建需求。任务依赖性定义了任务之间的执行关系，确保了在构建过程中，任务能够按照预期的顺序执行。任务是一个特殊的任务，它默认依赖于所有没有显式排除的任务。方法来指定任务的依赖性。
maven项目容器化运行之1-基于1Panel软件将docker镜像构建能力分享给局域网
qq_37372909的博客
07-15 533
docker核心功能包括镜像的构建和容器的运行，它可以开放端口将镜像构建的能力暴露。docker daeson就是docker的守护进程，开放能力是通过指定docker守护进程监听端口来实现的。后面开发人员就可以通过maven中docker插件来远程调用docker镜像构建能力了。
Java实验2
qq_64727229的博客
07-16 522
类的封装、继承、多态和接口（1）有理数四则运算（2）最终得分
每 日练 习
m0_67187271的博客
07-19 501
正确答案：C 解析：是正确的，这是最基本的类定义形式，没有继承任何类，也没有实现任何接口。也是正确的，这里定义了一个名为x的类，它继承了名为y的类。同样是正确的，这里定义了一个公共类x，它继承了Applet类，这在Java中是合法的，尤其是在创建GUI应用程序时常见。是不正确的，因为在Java中，我们不能使用static关键字来修饰一个类的定义。static关键字只能用于类的方法、变量或者是内部类（即嵌套类），但不能用于顶级类（非嵌套类）。所以，这个选项是错误的。因此，正确答案是C。
用JAVA写一个哈希表
03-23
好的，以下是一个简单的JAVA哈希表的实现： ``` import java.util.HashMap; public class MyHashTable { public static void main(String[] args) { HashMap<String, Integer> myHashTable = new HashMap<String, Integer>(); myHashTable.put("apple", 1); myHashTable.put("banana", 2); myHashTable.put("orange", 3); System.out.println(myHashTable.get("apple")); System.out.println(myHashTable.get("banana")); System.out.println(myHashTable.get("orange")); } } ``` 这个哈希表使用了Java内置的HashMap类，可以存储键值对。在这个例子中，我们将三个水果作为键，将它们的编号作为值存储在哈希表中，并通过get方法获取键对应的值。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值