哈希表的详细介绍及其实现~

已于 2022-03-25 23:52:27 修改
阅读量1.5k 收藏 2
点赞数 1
分类专栏： 数据结构 文章标签： java
于 2022-03-25 21:12:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57603004/article/details/123742283
版权

哈希冲突：不同的关键字通过相同的哈希函数，有可能找到相同的位置

如何避免冲突：（冲突的发生是必然的，但我们能做的应该是尽量的降低冲突率）

1、设计哈希函数来比避免冲突

（1）哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1 之间，就是散列表有多少格子就用多少格子的意思

（2）哈希函数计算出来的地址能均匀分布在整个空间中

（3）哈希函数应该比较简单
2、调节负载因子来比避免冲突 （重点）

常见哈希函数：

1. 直接定制法 --(常用 )
取关键字的某个线性函数为散列地址： Hash （ Key ） = A*Key + B 优点：简单、均匀
缺点：需要 事先知道关键字的分布情况         使用场景： 适合查找比较小且连续的情况
思路：因为知道了字符串中都是小写字母，就是 事先知道关键字的分布情况 
           小写字母还是连续的并且范围较小，所以可以用哈希的方法 
    public int firstUnique(String s){
        if(s==null){
            return -1;
        }
        int[] array=new int[26];
        for (int i = 0; i < s.length(); i++) {//第一次遍历str，把里面的元素都放入array里
            char ch=s.charAt(i);
            array[ch-97]++;
        }
        for (int i = 0; i <s.length() ; i++) {//第二次遍历str，每遍历一个元素上array里检查一下，若为1，则返回
            char ch=s.charAt(i);
            if(array[ch-97]==1){
                return i;
            }
        }
        return -1;
    }

2. 除留余数法--(常用)

设散列表中允许的 地址数为 m ，取一个不大于 m ，但最接近或者等于 m 的质数 p 作为除数，按照哈希函数： Hash(key) = key% p(p<=m), 将关键码转换成哈希地址

负载因子=存储散列表元素的个数/散列表的长度（负载因子=0.75，一旦大于0.75需要调节）

负载因子和冲突的关系：

 可知：负载因子越小，冲突率越低

要想降低冲突，需要将负载因子降低，由于存储散列表元素的个数在慢慢增加，所以要想负载因子降低只能提高散列表的长度，因此要想降低冲突，需要提高散列表的长度

由于冲突是避免不了的，那真正发生冲突又该怎么解决呢？

1、闭散列（开放地址法）：就是去寻找下一个为空的位置

   （1）线性探测：从冲突的位置开始向后找找到第一个为空的位置将元素放进去

 

缺点：会把冲突的元素都放到一起了，这样就不能随便删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如删除元素4，如果直接删除掉，44查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。

 （2）二次探测：

 缺点：空间利用率较低，只能装一半的元素，如果超出必须考虑增容。

2、（重点）开散列（哈希桶HashBuck/链地址法/开链法）

底层就是：数组（数组里面存的是Node）+链表

有人会担心，链表长度万一很长，遍历的时候时间复杂度不就会变成O（N）嘛？ 

这点请放心，因为链表的长度不会很长，控制在常数范围内，因为需要控制负载因子。

从JDK1.8开始，当链表长度超过8，并且数组的长度超过64时，这个链表就会变成红黑树

红黑树查找非常高效，不用担心时间复杂度问题。

通常认为哈希表的插入/删除/查找时间复杂度是 O(1)

 1、简单实现哈希表~

public class HashBuck {
    static class Node{
        public int key;
        public int val;
        public Node next;
        public Node(int key,int val){
            this.key=key;
            this.val=val;
        }
    }
    public Node[] array;
    public int usedSize;
 
    public static final double DEFAULT_LOAD_FACTOR=0.75;//规定负载因子，添加数据时检查一下，防止冲突
 
    public HashBuck(){
        this.array=new Node[10];
    }
    //添加元素
    public void put(int key,int val){
        //1、找到key所对应在array中的位置
        int index=key% array.length;
        //2、遍历index位置的链表，看key是否重复，重复则替换，若key不在则插入链表中
        //2.1重复的时候
        Node cur=array[index];
        while(cur!=null){
            if(cur.key==key){
                cur.val=val;//key重复，替换val
                return;
            }
            cur=cur.next;
        }
        //2.2不重复的时候：头插法插入
        Node node=new Node(key, val);
        node.next=array[index];//绑定尾部
        array[index]=node;//绑定头部
        usedSize++;
        //3、检查负载因子，超出负载因子的值，则需要扩大array的容量来减小负载因子的值，防止冲突
        if(loadFactor()>=DEFAULT_LOAD_FACTOR){
            resize();//扩容array的方法
        }
    }
    //扩容array需要注意：此时由于array扩容变长 需要将原来没扩容之前的节点都拿出来，
    // 然后重新哈希每个节点找在扩容后数组中的位置
    private void resize(){
        Node[]newArray=new Node[2*array.length];
        for (int i = 0; i < array.length; i++) {//遍历原来的数组，将里面的节点全都拿出来
            Node cur=array[i];//拿里面的节点
            while(cur!=null){//有可能array里的每个位置里都不止一个节点，而是一个链表
                int index=cur.key%newArray.length;//找到节点在扩容后数组中的位置
                Node curNext=cur.next;
                cur.next=newArray[index];//绑定后面
                newArray[index]=cur;//绑定前面
                cur=curNext;
            }
        }
        array=newArray;//让扩容后的数组代替原来的数组
    }
 
    private double loadFactor(){//求当前的负载因子值
        return 1.0*usedSize/array.length;//负载因子=当前数据长度/数组长度
    }
 
    //根据key获取val值
    public int get(int key){
        //1、找key的位置（大概找到key所在array数组的哪个下标里）
        int index=key%array.length;
        //2、遍历这个下标的链表具体找到key
        Node cur=array[index];
        while(cur!=null){
            if(cur.key==key){
                return cur.val;
            }
            cur=cur.next;
        }
        return -1;
    }
 
    public static void main(String[] args) {
        HashBuck hashBuck=new HashBuck();
        hashBuck.put(1,1);
        hashBuck.put(2,2);
        hashBuck.put(4,4);
        hashBuck.put(6,6);
        hashBuck.put(13,13);
        hashBuck.put(12,12);
        hashBuck.put(11,11);
        hashBuck.put(8,8);
        System.out.println(hashBuck.get(11));
    }
}

关于hashCode函数：可以使一个引用变成一个合法的整数

//假设接下来的key是一个person，身份证号是一样的，我们认为是同一个人
//又因为，要把person1和person2放到散列表中，需要找到index，所以需要调用person.hashcode(),找到下标
class Person{
     public String ID;
     public Person(String ID){
          this.ID=ID;
     }
      @Override
     public String toString() {
          return "Person{" +
                  "ID='" + ID + '\'' +
                  '}';
     }
}
public static void main(String[] args) {
          Person person1=new Person("123");
          Person person2=new Person("123");
          System.out.println(person1.hashCode());
          System.out.println(person2.hashCode());
}

 因为是同一个人，所以需要生成的值是一样的，这样才能存到同一位置，可是按照上面显然是不能达到预期的，因此还需要加东西，让生成的hashCode值相同

class Person{
     public String ID;
     public Person(String ID){
          this.ID=ID;
     }
     @Override
     public boolean equals(Object o) {
          if (this == o) return true;
          if (o == null || getClass() != o.getClass()) return false;
          Person person = (Person) o;
          return Objects.equals(ID, person.ID);
     }
     @Override
     public int hashCode() {
          return Objects.hash(ID);
     }
     @Override
     public String toString() {  
          return "Person{" +
                  "ID='" + ID + '\'' +
                  '}';
     }
}

public class HashBuck2 {
     public static void main(String[] args) {
          Person person1=new Person("123");
          Person person2=new Person("123");
          System.out.println(person1.hashCode());
          System.out.println(person2.hashCode());
     }
}

 重写了hashCode和equals后发现生成的值相等了，满足了预期

总结：因为HashMap底层是一个哈希表，所以在使用HashMap时如果map里面存的key值是自定义类型，一定要重写HashCode

像这种情况就要重写。 否则就会出现本意是一个人的两个人，最终被误认为不是一个人，被放到了不同位置

2、改进实现哈希表

import java.util.Objects;
//改进哈希表（由于哈希表里面的值不一定是整数）
class Person{
    public String ID;
    public Person(String ID){
        this.ID=ID;
    }
 
    @Override
    public String toString() {
        return "Person{" +
                "ID='" + ID + '\'' +
                '}';
    }
    //如果哈希表里存的树自定义对象时，在进行插入和查找时要重写equals（）和hashCode（）两个方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return Objects.equals(ID, person.ID);
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(ID);
    }
}
public class HashBuck2 <K,V>{
static class Node<K,V>{
    public K key;
    public V val;
    public Node<K,V> next;
    public Node(K key,V val){
        this.key=key;
        this.val=val;
    }
}
 
public Node<K,V>[] array=(Node<K,V>[])new Node[10];
public int usedSize;
public void put(K key,V val){
    int hash=key.hashCode();//通过hashCode（）来将一个字符串转换成对应值，
    // 进而通过生成的值来找其在array数组中的位置
    int index=hash%array.length;
    Node<K,V> cur=array[index];
    while(cur!=null){
        if(cur.key.equals(key)){
            cur.val=val;
            return;//此时相同的值再次插入，替换完val值后return
        }
        cur=cur.next;
    }
    Node<K,V> node=new Node<>(key,val);
    node.next=array[index];
    array[index]=node;
    this.usedSize++;
}
public V get(K key){
    int hash=key.hashCode();
    int index=hash%array.length;
    Node<K,V> cur=array[index];
    while(cur!=null){
        if(cur.key.equals(key)){
            return cur.val;
        }
        cur=cur.next;
    }
    return null;
}
 
    public static void main(String[] args) {
        Person person1=new Person("123");
        Person person2=new Person("123");
        HashBuck2<Person,String> hashBuck2=new HashBuck2<>();
        hashBuck2.put(person1,"ly");
        System.out.println(hashBuck2.get(person2));
    }
 
    public static void main1(String[] args) {
        Person person1=new Person("123");
        Person person2=new Person("123");
        System.out.println(person1.hashCode());
        System.out.println(person2.hashCode());
    }
 
 
}
总结：
1. HashMap 和 HashSet 即 java 中利用哈希表实现的 Map 和 Set
2. java 中使用的是哈希桶方式解决冲突的
3. java 会在冲突链表长度大于一定阈值后，将链表转变为搜索树（红黑树）
4. java 中 计算哈希值 实际上是 调用的类的 hashCode 方法 ， 进行 key 的相等性比较 是调用 key 的 equals方 法 。
所以 如果要用自定义类作为 HashMap 的 key 或者 HashSet 的值，必须覆写 hashCode 和 equals 方法 ，而且要做到 equals 相等的对象， hashCode 一定是一致的
哈希表的原理及其在实际中的应用
一键难忘的博客
05-23 976
哈希表是一种数据结构，用于存储键值对（key-value pairs）。它通过哈希函数将键映射到表中的一个位置，从而实现高效的数据访问。哈希表的特点在于，通过哈希函数计算出的位置是固定的，因此可以在常量时间内（O(1)）查找、插入和删除元素。哈希表作为一种重要的数据结构，在实际应用中发挥着关键作用。本文深入探讨了哈希表的原理、哈希函数、哈希冲突处理以及实际应用场景。我们了解到，哈希表通过哈希函数将键映射到固定位置，实现了快速的数据存储和查询，具有常量时间复杂度的优势。
哈希表的工作原理及其优化策略
一键难忘的博客
05-23 902
通过选择合适的哈希函数、处理冲突的方法以及高级优化策略，可以进一步提升哈希表的性能。当哈希表的负载因子过高时，可以重新分配一个更大的哈希表，并将所有现有元素重新哈希到新的哈希表中。选择一个合适的哈希函数可以显著减少冲突的概率。为了应对高并发和大量数据的访问，内存缓存系统通常采用先进的哈希表优化策略，如再哈希和高效哈希函数。双重散列是一种开放地址法的改进技术，通过使用两个不同的哈希函数来计算探测序列，从而减少冲突的概率。除了基本的优化策略，哈希表还有一些高级的优化技术，可以在特定场景中进一步提升性能和效率。
哈希表查找(C语言实现)
03-24
NULL 博文链接：https://touch-2011.iteye.com/blog/1090305
哈希表的实现
appup的博客
04-19 2271
1、哈希表 说明1 说明2 哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 哈希表hashtable(key，value) 就是把Key通过一个固定的算法函数既所谓的哈希函数转换成一个整型数字，然后就将该数字对数组长度进行取余，取余结果就当作数组的下标，将value存储在以该数字为下标的数组空间里。参考 1、利用链地址法实现
[redis命令]哈希命令
最新发布
fronge的博客
09-24 377
【代码】[redis命令]哈希命令。
哈希表的简单实现
qq_52575999的博客
02-27 337
在学习数据结构时，看到了有关哈希表的使用，虽然STL模板库里已有相关的实现，但我想简单实现下它的功能。 哈希表可以通过哈希函数来存储和查找值，这里我使用了较为简单的哈希函数，大大增加了其冲突的概率，我对冲突的处理使用的是链地址法。 虽然我使用了模板，但其实只限于 对int类型的处理，这跟我的哈希函数有关，往后我会改进，先写个简陋的版本。 #include <iostream> template<typename T=int> class Hash{ enum state
哈希算法是怎么实现的
weixin_33909059的博客
12-04 238
有想过hash["A1"] = DateTime.Now;这句是怎么实现的吗？我们来重温下学校时代就学过的哈希算法吧。 我们要写个class，实现如下主程序调用： static void Main(string[] args) { MyHash hash = new MyHash(); hash["A1"] = Date...
数据结构与算法 — 哈希函数及其实现、哈希表的实现、哈希表的扩容
m0_59897687的博客
01-10 1119
java中哈希表及其应用详解
09-03
Java中的哈希表，也称为散列表，是一种高效的数据存储结构，它利用了哈希函数将键（Key）映射到存储位置，从而实现快速访问。哈希表的核心在于哈希函数，它能够将键转化为数组索引，使得在理想情况下，通过键可以...
JS模拟实现哈希表及应用详解
12-08
本文将详细介绍如何使用JavaScript模拟哈希表以及其在实际问题中的应用。 首先，我们来看一下在JavaScript中操作对象属性的一些基本知识点： 1. **属性的枚举**：可以使用`for...in`循环来枚举对象的所有可枚举...
哈希表的设计与实现【课程设计】
06-23
哈希表的设计与实现课程设计 问题描述：针对某个单位电话号码簿，设计一个哈希表，并完成相应的建表和查表程序。 基本要求：设每个记录有下列数据项：电话号码、用户名、住址。从键盘输入各记录，以用户名为关键字建立哈希表，哈希函数用除留取余数法构造，采用线性探测法解决冲突。可以插入、查找、删除并显示给定用户名的记录，并计算查找长度, 哈希表保存到文件中，并能从文件中读取数据。 测试数据：取某个单位电话号码簿中的30个记录。 提高要求： (1)将电话号码薄以文件形式保存到盘上，能够按用户名和电话号码两种形式建立哈希表并实现插入、查找、删除表中元素的功能。 (2)对于相同的哈希函数，采用两种或两种以上的处理冲突的方法，如线性探测法和拉链法，比较不同的处理冲突的方法平均查找长度的变化。测试时，采用同一组测试数据，分别用不同的方法处理冲突，记录并输出各自的平均查找长度。 (3)设计图形用户界面
哈希表原理及hashmap简单实现
weixin_33805557的博客
07-21 163
哈希表也叫做散列表。在各种语言中都有hashmap的实现。其最突出的优点是查找和插入以及删除具有常数的时间复杂度 我们可以把哈希表理解为数组+链表 数组具有常数复杂度的查找,为什么呢，因为数组是在内存中连续存放，当我们索引某个位置的元素时候根据 索引值自动计算距离数组首元素起始位置的内存间隔。然而对于中间插入和中间删除元素，数组会将待插入位 置后面的原素先整体向后移动一个位置再将元素...
怎样实现一个哈希表
weixin_35754962的博客
01-03 396
要实现一个哈希表，需要以下步骤： 定义哈希表的数据结构，通常包括一个长度为m的数组和一个哈希函数。 实现哈希函数，它将输入的键转换为数组下标。 实现哈希表的基本操作，包括插入、查找、删除等。 对于哈希冲突，采用一定的解决方法，如开链法、开放寻址法等。 具体来说，哈希表可以用数组来实现，数组的每个元素都是一个链表的头节点。那么插入时，可以先使用哈希函数计算出数组下标，然后在对应的链表中插...
如何实现一个哈希表
weixin_53851750的博客
06-27 570
哈希表在Java集合中属于HashSet和HashMap的底层实现，它的查找效率非常的高，优于前面所学的链表顺序表，二叉搜索树等等，并且更是作为现代分布式系统的基础，由此可见它在众多数据结构中的重要性，下面具体实现一个哈希表。 哈希表主要由两个部分组成 1.一个数组 2.记录实际元素个数的变量size 具体实现过程就是把我们需要存储的元素映射成数组下标进行存储，当需要对哈希表进行操作的时候就根据映射出来的这个哈希值来访问具体的元素。 比如说给定我们若干个数字0——99之间，然后我们需要判断哪个数字是否存在于
哈希查找实现
weixin_51700854的博客
12-12 468
哈希查找（数据结构作业），这里只列举了线性探测法，还有二次探测法（左右摆头），链地址法可以自行理解 /* 第七章查找数据结构作业 date:2021/12/10 content:哈希查找实现(线性探测法处理冲突) mind: 1.创建哈希表 2.核心代码是线性探测，向右顺位思想，走到尾无位置，再从头开始顺位 测试用例为课本232页第5题 散列表的地址范围为0-17，散列函数为H(key)=key%16 已存入关键字序列:(10,24,32,17,31,30,46,47,40,63,49) 直接输入.
【数据结构】哈希表的原理及其实现
稻草人敲代码的博客
05-26 1121
哈希表类主要有两个模块需要实现，一个是节点类，还有一个是存储节点的容器。跟线性探测代码不一样的地方在于，拉链法的节点实际上是一个链表的头节点（桶）。值得注意的是，由于线性探测法的特性，删除一个元素之后可能会影响后续查找元素。造成哈希冲突的主要原因是，哈希表的大小是有限的，而输入的数据可能会非常多，因此不可能避免出现哈希冲突。于是，当我们发生哈希冲突时，不用去哈希表中找空位了，因为当前桶是一个单链表，插入元素时直接头插就好了。该文件封装实现了一个哈希表类，哈希函数是除留余数，解决哈希冲突的方法采用拉链法。
实现哈希表
冯同学的博客
05-29 613
用除留余数法作为哈希函数 用开放定址法(一次线性探测和二次线性探测)、链地址法的方式处理哈希冲
哈希表实现
qq_44392492的博客
07-27 274
哈希表哈希表的介绍和内存布局哈希表的图解，哈希表实现 案例案例思路图解 哈希表的介绍和内存布局 先看一个实际需求，google公司的一个上机题: 有一个公司,当有新的员工来报道时,要求将该员工的信息加入(id,性别,年龄,住址…),当输入该员工的id时,要求查找到该员工的 所有信息. 要求: 不使用数据库,尽量节省内存,速度越快越好=>哈希表(散列) 散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值