哈希表学习

最新推荐文章于 2024-07-15 11:23:08 发布
最新推荐文章于 2024-07-15 11:23:08 发布
阅读量137 收藏
点赞数
分类专栏： 数据结构 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/upset_poor/article/details/120481989
版权
哈希表是一种数据结构，通过哈希函数将键转换为索引，实现快速查找。哈希冲突是其核心问题，解决方法包括链地址法和开放地址法等。Java中的`hashCode()`方法用于生成哈希值。哈希表动态空间处理涉及扩容和缩容，以保持平均复杂度接近O(1)。此外，文章还讨论了不同类型的键如何通过哈希函数转换以及自定义对象的哈希处理策略。
摘要由CSDN通过智能技术生成

哈希表

哈希表基础

什么是哈希表

每一个字符都和一个索引相对应
O(1)的查找操作

哈希函数：“键”转换为“索引”
哈希冲突：不同的键经过哈希函数映射，对应了同一个索引
解决哈希冲突是关键问题

哈希表充分体现了算法设计领域的经典思想: 空间换时间
如果我们有无限的空间，可以用o(1)时间完成各项操作
如果我们只有1的空间，则只能用o(n)时间完成各项操作（线性表）
哈希表是时间和空间的平衡
哈希函数的设计是很重要的

哈希函数的设计

“键”通过哈希函数得到的“索引”越均匀越好

整型

小范围正整数直接使用
小范围负整数进行偏移 -100 ~ 100 ——> 0 ~ 200

大整数
比如身份证号4409…
通常做法：取模 ，比如，取后四位 等于mod 10000
取模一个简单通用的方法：模一个素数 背后数学原理超出课程范畴
在这里插入图片描述

浮点型

在这里插入图片描述

字符串

所占空间数量不固定
仍能转成整形处理
把一个字符串看出26进制的整型
在这里插入图片描述
B看成多少进制
上述哈希函数可以化简为：
在这里插入图片描述
根据哈希函数设计出函数
在这里插入图片描述

复合类型

转成整型处理
仍可以像字符串一样处理
在这里插入图片描述

总结

转成整型处理，并不是唯一方法

原则：

  1. 一致性：如果a == b，则hash(a) == hash(b)，反过来不成立
  2. 高效性：计算高效简便
  3. 均匀性：哈希值均匀分布

java中的hashcode方法

java中基本类型不是对象

Integer i = 10;
System.out.println(i.hashCode());
double c = 3.1415926;
System.out.println(((Double)c).hashCode());
String s = "hhhasda";
System.out.println(s.hashCode());

整型输出结果为他本身
不能直接将整型转化为索引，因为不知道索引具体范围
double类型输出结果是一个整型
String类型输出结果是一个整型

自定义对象

/**
 * @author laimouren
 */
public class Student {
    private int grade;
    private int cls;
    private String firstName;
    private String lastName;

    public Student(int grade, int cls, String firstName, String lastName) {
        this.grade = grade;
        this.cls = cls;
        this.firstName = firstName;
        this.lastName = lastName;
    }

    @Override
    public int hashCode() {
        int B = 31;
        int hash = 0;
        hash = hash * B + grade;
        hash = hash * B + cls;
        hash = hash * B + firstName.toLowerCase().hashCode();
        hash = hash * B + lastName.toLowerCase().hashCode();

        return hash;
    }
	@Override
    public boolean equals(Object obj) {
        if(this == obj){
            return true;
        }
        if (obj == null){
            return false;
        }
        if (getClass() != obj.getClass()){
            return false;
        }
        Student another = (Student) obj;
        return this.grade == another.grade && this.cls == another.cls
                && this.firstName.toLowerCase() == another.firstName.toLowerCase()
                && this.lastName.toLowerCase() == another.lastName.toLowerCase();
    }    
}

测试

Student student = new Student(1,1,"lai","lai");
System.out.println(student.hashCode());

结果

3451552

注意：如果一个类要作为哈希表的键，重写了hashcode()方法的同时，还得重写equals()方法，以解决哈希冲突

哈希冲突的处理 链地址法（Seperate Chaining）

哈希表本质就是一个数组

通过哈希函数计算出的结果如果是相同的，则放在链表后面
在这里插入图片描述

在这里插入图片描述
java8之前，每一个位置对应一个链表
java8开始，当哈希冲突达到一定程度，每一个位置从链表转化为红黑树（因为java中treemap的底层就是红黑树）

具体实现

import java.util.TreeMap;

public class HashTable<K, V> {

    private TreeMap<K, V>[] hashtable;
    private int size;
    private int M;

    public HashTable(int M){
        this.M = M;
        size = 0;
        hashtable = new TreeMap[M];
        for(int i = 0 ; i < M ; i ++)
            hashtable[i] = new TreeMap<>();
    }

    public HashTable(){
        this(97);
    }

    private int hash(K key){
        return (key.hashCode() & 0x7fffffff) % M;
    }

    public int getSize(){
        return size;
    }

    public void add(K key, V value){
        TreeMap<K, V> map = hashtable[hash(key)];
        if(map.containsKey(key))
            map.put(key, value);
        else{
            map.put(key, value);
            size ++;
        }
    }

    public V remove(K key){
        V ret = null;
        TreeMap<K, V> map = hashtable[hash(key)];
        if(map.containsKey(key)){
            ret = map.remove(key);
            size --;
        }
        return ret;
    }

    public void set(K key, V value){
        TreeMap<K, V> map = hashtable[hash(key)];
        if(!map.containsKey(key))
            throw new IllegalArgumentException(key + " doesn't exist!");

        map.put(key, value);
    }

    public boolean contains(K key){
        return hashtable[hash(key)].containsKey(key);
    }

    public V get(K key){
        return hashtable[hash(key)].get(key);
    }
}

哈希表的动态空间处理

在这里插入图片描述
如何让时间复杂度变为O(1)?
固定地址空间是不合理的，需要resize()

  1. 平均每个地址承载的元素多过一定程度，即扩容 N/M >= upperTol
  2. 平均每个地址承载的元素少过一定程度，即缩容 N/M < lowerTol

具体实现如下：

import java.util.Map;
import java.util.TreeMap;

public class HashTable<K, V> {

    private static final int upperTol = 10;
    private static final int lowerTol = 2;
    private static final int initCapacity = 7;

    private TreeMap<K, V>[] hashtable;
    private int size;
    private int M;

    public HashTable(int M){
        this.M = M;
        size = 0;
        hashtable = new TreeMap[M];
        for(int i = 0 ; i < M ; i ++)
            hashtable[i] = new TreeMap<>();
    }

    public HashTable(){
        this(initCapacity);
    }

    private int hash(K key){
        return (key.hashCode() & 0x7fffffff) % M;
    }

    public int getSize(){
        return size;
    }

    public void add(K key, V value){
        TreeMap<K, V> map = hashtable[hash(key)];
        if(map.containsKey(key))
            map.put(key, value);
        else{
            map.put(key, value);
            size ++;

            if(size >= upperTol * M)
                resize(2 * M);
        }
    }

    public V remove(K key){
        V ret = null;
        TreeMap<K, V> map = hashtable[hash(key)];
        if(map.containsKey(key)){
            ret = map.remove(key);
            size --;

            if(size < lowerTol * M && M / 2 >= initCapacity)
                resize(M / 2);
        }
        return ret;
    }

    public void set(K key, V value){
        TreeMap<K, V> map = hashtable[hash(key)];
        if(!map.containsKey(key))
            throw new IllegalArgumentException(key + " doesn't exist!");

        map.put(key, value);
    }

    public boolean contains(K key){
        return hashtable[hash(key)].containsKey(key);
    }

    public V get(K key){
        return hashtable[hash(key)].get(key);
    }

    private void resize(int newM){
        TreeMap<K, V>[] newHashTable = new TreeMap[newM];
        for(int i = 0 ; i < newM ; i ++)
            newHashTable[i] = new TreeMap<>();

        int oldM = M;
        this.M = newM;
        for(int i = 0 ; i < oldM ; i ++){
            TreeMap<K, V> map = hashtable[i];
            for(K key: map.keySet())
                newHashTable[hash(key)].put(key, map.get(key));
        }

        this.hashtable = newHashTable;
    }
}

哈希表的复杂度分析

回忆动态数组的均摊复杂度分析：平均复杂度为O(1)

同理，对于哈希表来说，元素从N增加到upperTol * N；地址空间翻倍
从而平均复杂度为O(1)

每个操作在O(lowerTol) ~ O(upperTol) ——>O(1)

缩容同理

更复杂的动态空间处理方法

扩容 M -> 2 M
扩容结果2M不是素数
解决方案：
根据下表来设置扩容
在这里插入图片描述
缺点：
哈希表牺牲了顺序性

更多哈希冲突的解决方法

开放地址法

原先实现的是封闭地址，只能对应的key访问
![在这里插入图片描述](https://img-blog.csdnimg.cn/b7bcdb3dfc9e4be78cf3ef5796e012e6.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA6LWW5oC75Yay5Yay5Yay,size_20,color_FFFFFF,t_70,g_se,x_16)

在这里插入图片描述
在这里插入图片描述
开放地址法中，当负载率达到一定程度就需要扩容
只要负载率选的合适，时间复杂度就是O(1)

再哈希法 Rehashing

Coalesced Hashing

综合了Seperate Chaining 和Open Addressing

学而知不足~
关注
专栏目录
XCPC第七站！带你学懂哈希表！
m0_73401638的博客
03-01 663
XCPC第七站——哈希表！
哈希表学习笔记.docx
05-08
### 哈希表学习笔记知识点详述 #### 一、什么是哈希表？ 哈希表是一种高效的数据存储结构，其基本思想是通过一个特定的函数（哈希函数或散列函数）将输入的关键字映射到一个固定大小的空间内，从而实现数据的快速...
哈希表的学习
捕翼^的博客
05-16 190
哈希表 哈希表介绍： 散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。如下图： 比如：111 % 15 = 15，那么111这个数字就放在索引15的位置 提高访问速度的方法： google公司的一个上机题: 有一个公司,当有新的员工来报道时,要求将该员工的信息加入(id,性别,年龄,名字,住址…),当输入该员工的id时,要
【基础算法总结】哈希表
最新发布
fight_p的博客
07-15 2556
哈希表是什么?存储数据的容器有啥用？“快速” 查找某个元素。时间复杂度O(1)什么时候用哈希表？频繁的查找某一个数的时候。频繁查找某一个数的时候，我们还要想到一个二分查找也可以快速查找某一个元素，但是二分因为有些局限，具有二段性才可以用二分，它也比较快，时间复杂度O(logn)。而且能用二分我们尽量用二分，因为哈希表虽然非常快，但是它空间复杂度是O(n)。怎么用哈希表？容器（哈希表）用数组模拟简易哈希表关注字符串中的 “字符”
算法学习之哈希表
continue_gdufe的博客
09-12 149
算法学习之哈希表前言一、哈希表1.什么是哈希表2.关于API文档中HashTable3.代码随想录中的经典讲解①通过哈希函数来快速查询学生是否在学校②哈希冲突4.常见的哈希结构二、小试牛刀，解决问题1.有效的字母异位词2.总结 前言 从这篇开始，我们又进入了一个新的领域的学习，也就是集合。 学习数组，在数组中查找数据，我们会感觉很方便，但是遇到需要在数组中某个元素的增删，往往又会很耗费资源 学习链表，在链表中对特定或者是需要的元素进行增删时，也是极佳的解决方案，但是涉及到查找结点值时却也束手无策 而本系列
易语言哈希表学习例程源码
06-02
在标题提到的“易语言哈希表学习例程源码”中，我们可以预期会包含一些关于如何创建、操作和理解哈希表的示例代码。这些源码可能涵盖了以下关键知识点： 1. **哈希表创建**：在易语言中，创建哈希表通常涉及指定表...
易语言源码易语言哈希表学习例程源码.rar
03-31
这份"易语言哈希表学习例程源码.rar"压缩包提供了易语言中哈希表的实践案例，可以帮助学习者深入理解哈希表的工作原理和易语言的相关实现。 哈希表的核心在于哈希函数，它将输入（通常是字符串或其他数据类型）转化...
哈希表 学习
weixin_34179968的博客
01-15 74
看了几篇文章，主要意思就是用简单的值index，去索引复杂的值key，进而找到想要的值value. 哈希算法主旨：index = f(key) 数据存放格式：(key.value) 但是存在问题是， 1.哈希算法使不同的key产生相同的index 2.分配给哈希表的内存满了之后，整个哈希表的迁移太累赘了。 针对第一个问题，下面介绍两个方案： 拉链法：http://www...
HASH（哈希表）学习
小熊诺诺
11-24 591
1. 什么是哈希表： Hash，一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。
哈希表实现与查找操作
"哈希表实例" 哈希表是一种数据结构，它提供了快速的数据存取方式，通过将数据的关键字（Key）映射到一个固定...学习哈希表对于理解数据结构和算法非常重要，因为它在许多高效数据处理和缓存系统中扮演着核心角色。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值