Java基础(5)-散列表与HashMap那点事

海思MIPI屏调试实战:从参数计算到点亮屏幕的完整指南 本文提供了一份海思平台MIPI屏幕调试的完整实战指南。文章以Hi3516DV300调试800x1280分辨率屏幕为例,详细讲解了从参数计算、配置文件修改到最终点亮屏幕的全流程,并分享了常见问题排查与进阶优化技巧,旨在帮助嵌入式开发者高效解决MIPI屏调试难题。 阅读详情

一. 散列表概述

HashMap是Java语言中的一种十分常用的数据结构,它是一种基于散列表(哈希表)的键值对实现,它继承自AbstactMap并实现了Map接口;所以首先需要介绍一下散列表相关知识.

1.1 散列表是什么

散列表(Hash table,也叫哈希表),是根据键(Key)而直接访问在内存存储位置的数据结构。也就是说,它通过计算一个关于键值的函数,将所需查询的数据映射到表中一个位置来访问记录,这加快了查找速度。这个映射函数称做散列函数,存放记录的数组称做散列表。

若关键字为 k,则其值存放在 f(k)的存储位置上。由此,不需比较便可直接取得所查记录。称这个对应关系 f为散列函数,按这个思想建立的表为散列表。

1.2 散列表的实现形式

散列表有许多实现形式,其中最常用的实现形式有两种:一种是基于红黑树的实现(TreeMap),即每个红黑树节点存储着Key和Value,当使用Key查询红黑树节点时,可以做到最坏O(logn)的时间复杂度;

在这里插入图片描述

第二种实现是基于数组与链表的实现,即每个Key通过哈希函数处理之后变成一个数组的索引Index,通过Index找到数组中的链表节点,并且通过Key去对比链表节点的Key值,从而确定出该节点,得到其Value,这种做法被运用在了HashMap中,在最好情况下,查询一个Key的Value的时间复杂度为常数级O(1)(经过哈希求index后,没有产生哈希冲突),而最坏情况是O(k),即在求Index的时候,发现出现了哈希冲突,即链表中含有k个元素,此时需要遍历这k个元素去寻找到Key.

在这里插入图片描述
既然说到了散列函数和哈希冲突, 那么下文即将对这两个方面展开介绍.

二. 散列函数

散列函数f的作用是对key进行处理,使得f(key)=index,在下次需要找到key的value时,只需要再次调用f(key)即可直接计算出index,时间复杂度为O(1);散列函数的选取对于散列表性能来说至关重要,好的散列函数能够极大地减少哈希冲突的产生.

  • 散列函数具备的特性:
    1.简单快速:散列函数的计算需要简单和快速
    2.经过散列函数计算出的值能均匀地映射到存储地址空间中
    3.任何时间,同一key计算出来的散列值必须是相等的

  • 散列函数的类型
    1.直接寻址法:即直接使用一个与key线性相关的函数作为散列函数,例如f = a * key + k,其中a和k是常数.
    2.数字分析法:分析一组数据,找出数字的规律,尽可能利用这些数字构造冲突几率低的散列地址.
    3.除余法:这是求哈希值的常见方法,即f(key) = key % m,其中m为存储空间长度,这与就可以使得key的哈希值一定落入[0, m - 1]这个存储空间中;需要注意的是m最好选择为素数,这样可以使得哈希值分布更加均匀(数学证明忽略).
    4.随机数法
    5.平方取中法

三. 哈希冲突与解决方案

选用哈希函数计算哈希值时,可能不同的 key 会得到相同的结果,这被称为哈希冲突;而如何在同一个内存地址中存储多个结果,这就是哈希冲突的解决方案.
在这里插入图片描述

常见解决方案:

3.1.拉链法

拉链法是一种解决哈希冲突的常用手段,它将所有关键字为同义词的结点链接在同一个单链表中:

若选定的散列表长度为 m,那么散列表定义为一个由 m 个头指针组成的指针数组 nodes[0,m-1] 。

凡是散列值为 i 的结点,均插入到以 nodes[i] 为头指针的单链表中。
nodes中各分量的初值均应为空指针。

这样就可以解决哈希冲突了.
在这里插入图片描述

3.2. 开放定址法

以下转载自https://blog.youkuaiyun.com/u011240877/article/details/52940469

用开放定址法解决冲突的做法是:当冲突发生时,使用某种探测技术在散列表中形成一个探测序列。沿此序列逐个单元地查找,直到找到给定的关键字,或者碰到一个开放的地址(即该地址单元为空)为止(若要插入,在探查到开放的地址,则可将待插入的新结点存人该地址单元)。查找时探测到开放的地址则表明表中无待查的关键字,即查找失败。

简单的说:当冲突发生时,使用某种探查(亦称探测)技术在散列表中寻找下一个空的散列地址,只要散列表足够大,空的散列地址总能找到。

按照形成探查序列的方法不同,可将开放定址法区分为线性探查法、二次探查法、双重散列法等。

a.线性探查法

hi=(h(key)+i) % m ,0 ≤ i ≤ m-1

基本思想是:
探查时从地址 d 开始,首先探查 T[d],然后依次探查 T[d+1],…,直到 T[m-1],此后又循环到 T[0],T[1],…,直到探查到 有空余地址 或者到 T[d-1]为止。

b.二次探查法

hi=(h(key)+i^2) % m,0 ≤ i ≤ m-1

基本思想是:
探查时从地址 d 开始,首先探查 T[d],然后依次探查 T[d+12],T[d+22],T[d+3^2],…,等,直到探查到 有空余地址 或者到 T[d-1]为止。

缺点是无法探查到整个散列空间。

c.双重散列法

hi=(h(key)+i*h1(key)) % m,0 ≤ i ≤ m-1

基本思想是:
探查时从地址 d 开始,首先探查 T[d],然后依次探查 T[d+h1(d)], T[d + 2*h1(d)],…,等。

该方法使用了两个散列函数 h(key) 和 h1(key),故也称为双散列函数探查法。

定义 h1(key) 的方法较多,但无论采用什么方法定义,都必须使 h1(key) 的值和 m 互素,才能使发生冲突的同义词地址均匀地分布在整个表中,否则可能造成同义词地址的循环计算。

该方法是开放定址法中最好的方法之一。

四. 载荷因子

散列表的载荷因子定义为:a = 填入表中的元素个数 / 散列表的长度

a 是散列表装满程度的标志因子。由于表长是定值, a 与“填入表中的元素个数”成正比,所以, a 越大,表明填入表中的元素越多,产生冲突的可能性就越大;反之,a 越小,标明填入表中的元素越少,产生冲突的可能性就越小。实际上,散列表的平均查找长度是载荷因子a 的函数,只是不同处理冲突的方法有不同的函数。

对于开放定址法,荷载因子是特别重要因素,应严格限制在0.7-0.8的范围。超过0.8,查表时的CPU缓存不命中(cache missing)按照指数曲线上升。因此,一些采用开放定址法的hash库,如Java的系统库限制了荷载因子为0.75,超过此值将resize散列表。

五. HashMap 概述

5.1.HashMap的简介

HashMap是基于哈希表的Map实现的的,一个Key对应一个Value,允许使用null键和null值,不保证映射的顺序,特别是它不保证该顺序恒久不变!也不是同步的。
怎么理解不保证恒久不变呢?

当哈希表中的条目数超出了加载因子与当前容量的乘积时的时候,哈希表进行rehash操作(即重建内部数据结构),此时映射顺序可能会被打乱!

HashMap存放元素是通过哈希算法将其中的元素散列的存放在各个“桶”之间。

5.2.HashMap的继承关系

类 HashMap<K,V>
java.lang.Object
继承者 java.util.AbstractMap<K,V>
继承者 java.util.HashMap<K,V>
类型参数:
K - 此映射所维护的键的类型
V - 所映射值的类型
所有已实现的接口:
Serializable, Cloneable, Map<K,V>

在这里插入图片描述

5.3 HashMap API
  • 构造函数:
//构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。 
HashMap() 
//构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap。 
HashMap(int initialCapacity) 
//构造一个带指定初始容量和加载因子的空 HashMap。 
HashMap(int initialCapacity, float loadFactor) 
//构造一个映射关系与指定 Map 相同的新 HashMap。 
HashMap(Map<? extends K,? extends V> m) 
  • 方法
//从此映射中移除所有映射关系
 void clear() 
//返回此 HashMap 实例的浅表副本:并不复制键和值本身。 
 Object clone() 
 //如果此映射包含对于指定键的映射关系,则返回 true。 
 boolean containsKey(Object key) 
 //如果此映射将一个或多个键映射到指定值,则返回 true。 
 boolean containsValue(Object value) 
 //返回此映射所包含的映射关系的 Set 视图。 
 Set<Map.Entry<K,V>> entrySet() 
  //返回指定键所映射的值;如果对于该键来说,此映射不包含任何映射关系,则返回 null。
 V get(Object key) 
//如果此映射不包含键-值映射关系,则返回 true。
 boolean isEmpty() 
//返回此映射中所包含的键的 Set 视图。
 Set<K> keySet() 
//在此映射中关联指定值与指定键。
 V put(K key, V value) 
 // 将指定映射的所有映射关系复制到此映射中,这些映射关系将替换此映射目前针对指定映射中所有键的所有映射关系
 void putAll(Map<? extends K,? extends V> m) 
//从此映射中移除指定键的映射关系(如果存在)。 
 V remove(Object key) 
 //返回此映射中的键-值映射关系数。 
 int size() 
//返回此映射所包含的值的 Collection 视图。 
 Collection<V> values() 

六. 底层基本实现

6.1 数组 + 链表

HashMap的底层实现是基于数组+链表的形式,数组用以存储链表,是典型的拉链法实现:

//链表节点
static class Node<K,V> implements Map.Entry<K,V> {
        //当前节点的哈希值,注意这个值并不是数组下标
        final int hash;
        //当前节点的key值
        final K key;
        //当前节点的value值
        V value;
        //后继节点
        Node<K,V> next;

        //...

        //判断节点之间是否相等
        public final boolean equals(Object o) {
            if (o == this)
                //如果是当前节点,则返回true
                return true;
            //如果是Map.Entry类型,则当key和value都相等时返回true
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

//用以存储链表节点的数组
transient Node<K,V>[] table;
6.2 两个重要参数:初始容量和加载因子

HashMap 的初始容量和加载因子 由于 HashMap 扩容开销很大(需要创建新数组、重新哈希、分配等等),因此与扩容相关的两个因素:

初始容量(DEFAULT_INITIAL_CAPACITY):初始化容量数量.
加载因子(DEFAULT_LOAD_FACTOR):决定了 HashMap 中的元素占有多少比例时扩容 成为了 HashMap 最重要的部分之一,它们决定了 HashMap 什么时候扩容.
最大容量(MAXIMUM_CAPACITY):HashMap所能存储的最大数据量.

//默认为16,其值一定要为2的次方
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 
//默认为0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//2的30次方
static final int MAXIMUM_CAPACITY = 1 << 30;
6.3 hash(Object o)方法

这是JDK 1.8中HashMap用以求得key哈希值的方法,与JDK 1.7的有一些不同.右位移16位,正好是32bit的一半,自己的高半区和低半区做异或,就是为了混合原始哈希码的高位和低位,以此来加大低位的随机性。而且混合后的低位掺杂了高位的部分特征,这样高位的信息也被变相保留下来,这将大大地减少哈希冲突,这段求哈希值的代码也可被称为"扰动函数".

详情请参见:https://www.zhihu.com/question/20733617

 static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

在这里插入图片描述

6.4 put(K key, V value)方法
public V put(K key, V value) {
        //调用putVal方法
        return putVal(hash(key), key, value, false, true);
    }


    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            //如果当前HashMap为空, 则调用resize()方法将其n置为初始容量
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            //如果tab[i] == null,则直接在这个位置插入新的链表
            tab[i] = newNode(hash, key, value, null);
        else {
            //如果tab[i] != ull, 说明发生了哈希冲突
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                //如果当前需要插入的节点的哈希值和key值都等于tab[i]这个节点的值,说明两者可以直接替换
                e = p;
            else if (p instanceof TreeNode)
                //jdk 1.8更新的红黑树结构
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        //寻找链表末尾进行插入
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            //已经到了转化为红黑树的阀值,将这条链表转化为红黑树
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // 已经存在了该节点映射,直接替换该Key的Value即可
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        //Fail-fast机制
        ++modCount;
        if (++size > threshold)
            //如果增加元素后大小超过了阀值(阀值=加载因子*初始化容量),那么进行两倍扩容
            resize();
        afterNodeInsertion(evict);
        return null;
    }
6.5 get(K key)方法
public V get(Object key) {
        Node<K,V> e;
        //先将key取hash值,调用getNode方法
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }


    final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            //(n - 1) & hash获取该链表所处的索引
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                //如果是链头,则直接返回
                return first;
            if ((e = first.next) != null) {
                if (first instanceof TreeNode)
                    //如果是红黑树的根,则直接返回
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {
                    //通过哈希值和key值不断地在链表中迭代寻找
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }
6.6 resize()方法

resize()方法是HashMap的扩容方法, 在进行元素的添加时,如果当前元素的数量已经等于阀值( 加载因子 *初始化容量) 时,将会对数组容量进行两倍扩容,以下是部分源码解析:

final Node<K,V>[] resize() {
        // 获取当前的table数组
        Node<K,V>[] oldTab = table;
        // 获取当前table数组的链表个数
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        // 获取当前table数组的扩容阀值
        int oldThr = threshold;
        // 新数组容量和阀值
        int newCap, newThr = 0;
        if (oldCap > 0) {
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                // 当前数组链表个数已经多于HashMap所内容纳的最大数目,不能扩容,返回当前数组
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                // 新阀值为之前的两倍
                newThr = oldThr << 1;  
        }
        else if (oldThr > 0)
            // 未到达扩容阀值,不进行扩容  
            newCap = oldThr;
        else {               
            //若当前容量为0,则进行容量的初始化和阀值的初始化
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
        //创建新的链表数组用以存储之前的旧数据,并且容量扩大
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    //将老链表数组的值置为null,释放的空间
                    oldTab[j] = null;
                    if (e.next == null)
                        //旧节点插入新数组的位置可能发送改变:
                        //i = e.hash & (newCap - 1)
                        //newTab[i] = e
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { 
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

七. JDK 1.8 新增红黑树结构

HashMap在jdk 1.8之前采用的是常规的 “数组 + 链表” 实现(基于避免哈希冲突的拉链法技术),在Jdk 1.8之后,
HashMap中的节点在特点情况下会变更为红黑树结构(当链表的元素大于8时,将会转变为红黑树存储这条链表的元素),这样
就能够避免在相同哈希值的情况下,即在数组的同一位置,进入过长的链表中进行搜索(在链表中搜索的时间复杂度为 O(n) ,
而在红黑树中搜索的时间能够维持在(logn) ).

在这里插入图片描述

7.1 HashMap关于红黑树的主要参数值
  1. TREEIFY_THRESHOLD:桶的树型化阀值,默认为8;当桶中的元素数量大于这个值时,桶中元素将变为使用红黑树存储.
    2.UNTREEIFY_THRESHOLD:桶在树型化之后,变为链表化的阀值,默认为6.
  2. MIN_TREEIFY_CAPACITY: HashMap采用树型化存储的阀值,默认为64,当HashMap中的元素个数大于这个值时才会出现桶存储结构树型化.
7.2 桶的树形化 treeifyBin()

在Java 8 中,如果一个桶中的元素个数超过 TREEIFY_THRESHOLD(默认是 8 ),就使用红黑树来替换链表,从而提高速度。

这个替换的方法叫 treeifyBin() 即树形化。

//将桶内所有的 链表节点 替换成 红黑树节点
final void treeifyBin(Node<K,V>[] tab, int hash) {
 int n, index; Node<K,V> e;
 //如果当前哈希表为空,或者哈希表中元素的个数小于 进行树形化的阈值(默认为 64),就去新建/扩容
 if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
     resize();
 else if ((e = tab[index = (n - 1) & hash]) != null) {
     //如果哈希表中的元素个数超过了 树形化阈值,进行树形化
     // e 是哈希表中指定位置桶里的链表节点,从第一个开始
     TreeNode<K,V> hd = null, tl = null; //红黑树的头、尾节点
     do {
         //新建一个树形节点,内容和当前链表节点 e 一致
         TreeNode<K,V> p = replacementTreeNode(e, null);
         if (tl == null) //确定树头节点
             hd = p;
         else {
             p.prev = tl;
             tl.next = p;
         }
         tl = p;
     } while ((e = e.next) != null);  
     //让桶的第一个元素指向新建的红黑树头结点,以后这个桶里的元素就是红黑树而不是链表了
     if ((tab[index] = hd) != null)
         hd.treeify(tab);
 }
}


TreeNode<K,V> replacementTreeNode(Node<K,V> p, Node<K,V> next) {
return new TreeNode<>(p.hash, p.key, p.value, next);
}

Thanks:

  • 维基百科
  • 算法第四版
  • https://blog.youkuaiyun.com/u011240877/article/details/52940469
  • https://blog.youkuaiyun.com/u011240877/article/details/52929523
  • https://blog.youkuaiyun.com/u013074465/article/details/45059639
  • https://blog.youkuaiyun.com/u010648555/article/details/60324303
  • https://www.zhihu.com/question/20733617
从零到一:ESP32-P4 PPA加速的配置陷阱与避坑指南 本文详细解析ESP32-P4结合LVGL的PPA硬件加速配置中的常见陷阱,包括内存对齐、缓冲区设置和同步机制等关键问题。提供实用的避坑指南和优化方案,帮助开发者高效启用esp32p4的PPA加速功能,显著提升图形渲染性能。 阅读详情

相关推荐

七、永磁同步电机矢量控制(FOC)—MTPA控制及Simulink仿真

前面几节的内容已经完成Id=0控制策略的理论和仿真以及双闭环PI参数整定。在接下来几节中,将陆续讲解MTPA、弱磁控制等内容。

weixin_45182459的博客 8198

Hash 哈希表和算法思路详解

取关键字key,使用线性函数 Hash(key) = a * key + b。在一个班级里,同龄学生很多。在取学生年龄作为key时,应避免以年份作为key组成部分。key取平方,截取中间的几位作为新的key。数学计算的性质乘积中间几位和乘数每一位都有关,充分混合key每一位对生成的哈希值的影响,使映射分布更均匀。Hash(key) = key % mHash(key) = floor(frac(key * A), m), 0Hash(key) = rand(key)将关键字按固定长度分成几段然后相加。由于哈

www_xuhss_com的博客 585

LLMOps的崛起:如何利用Langfuse和Opik构建高效的模型监控与评估体系

本文探讨了LLMOps的崛起,详细介绍了如何利用Langfuse和Opik构建高效的模型监控与评估体系。通过开源工具Langfuse的全景监控方案和Opik的三层评估体系,帮助AI工程团队实现大语言模型的全生命周期管理,提升模型性能和迭代效率。文章还提供了实战技巧和工具链集成方案,助力企业优化AI应用。

ll5678的博客 682

散列表、泛型

1 Set 1.1 HashSet使用 2、散列表 2.1 概述 *散列表结构 可以理解为 数组中保存的是联邦的首节点,用来保存k和v键值操作 * *hash算法:是一种安全的加密机制,可以把不定长的数据转换为定长数据,并且不能保证其唯一性,又叫哈希冲突 * *再Java中指的是hashCode方法 * *对一个对象生成多次hash值,值一定相同,多个对象也可能生成相同的hash值,叫哈希冲突 * *k不可重复,v可以重复 * *添加过程: * ...

asdsdsd25的博客 533

多任务学习中的过拟合陷阱:动态停止训练机制详解与避坑指南

本文深入剖析了多任务学习中因任务过拟合不同步导致的性能下降问题,并详细介绍了动态停止-继续训练机制。该机制通过为每个任务设置独立的训练开关,基于验证集性能动态控制其梯度更新,有效缓解了任务间负迁移,是提升多任务模型整体泛化能力的关键策略。

happy2的博客 1093

一文读懂GAN, pix2pix, CycleGAN和pix2pixHD

本文翻译、总结自朱俊伟的线上报告,主要讲了如何用机器学习生成图片。 来源:Games2018 Webinar 64期 :Siggraph 2018优秀博士论文报告 人员信息 主讲嘉宾 姓名:朱俊彦(Jun-Yan Zhu) 现状:麻省理工学院博士后(PostDoc at MIT),计算机科学与人工智能实验室(Computer Science and Artificial In...

gdymind的博客 6万+

散列表 - 哈希表(HashMap)

哈希表 - 手动实现HashMap

云梦归遥【qq_45834685】 603

基于LSTM的股票价格预测系统,Django框架,Web的股票预测系统,训练+数据集+源码(无需安装环境版)

股票价格预测是投资领域的一个重点关注课题。由于股票价格受到诸多非线性因素的影响,得到精确的预测结果较为困难。使用 PyCharm 作为代码开发工具,通过下载好的股票金融数据,进行数据预处理,构建 LSTM 网络模型,训练模型并训练出最优模型,输出股票未来收盘价波动的走势,最后在训练好的模型上,设计股票模型应用系统,运行效率较高,对股票预测具有一定的积极意义。

在职AI算法工程师,擅长计算机视觉,YOLO目标检测、分割等,擅长web、pyqt界面可视化,好内容持续更新中,来这里跟大家一起学习,共同进步 956

散列表查找失败平均查找长度_算法连载之散列表

散列表散列表(hash table)是实现字典操作的有效数据结构。在最坏情况下,查找一个元素的时间复杂度是O(n);而在合理假设情况下,查找一个元素的时间复杂度是O(1)。因此,散列表查找元素的性能是极好的。常用于作为在常量时间范围内辅助查找一个元素。对于普通数组,可以直接寻址,即可以直接通过数组下标访问一个元素。如果空间允许的话,可以将元素的key作为数组下标映射。但是,如果实际存储的元素要比实...

weixin_39771969的博客 2002

YOLOv11改进-卷积-引入Upsampling by Dynamic DySample 解决传统上采样灵活性问题

现有的上采样方法如等,依赖于动态卷积来生成上采样的内容感知核,但这些方法需要额外的子网络生成动态卷积核计算量较大。尤其是 FADE 和 SAPA 需要高分辨率的特征图作为引导,进一步增加了计算负担,并限制了应用场景。DySample的核心思想是将上采样过程重新定义为点采样(Point Sampling)。通过学习输入特征图中的采样点坐标,DySample 生成内容感知的采样点来对特征图进行重新采样,而不是使用动态卷积核。具体实现步骤如下:​​1. 输入特征图:大小为 C×H×W的输入特征图。

qq_64693987的博客 4663

修改yolov8使支持单通道图像输入

默认支持BGR三通道图像输入,但是在很多工业场景下,存在很多灰度图像的场景,因此对yolov8代码做一些修改以支持单通道图像输入,满足项目实际需求。训练时,只需要在 data 的 yaml 文件中,添加 ch=1 即可。

mingo_敏 5779

Map集合、散列表、红黑树介绍

前言 声明,本文用得是jdk1.8 前面已经讲了Collection的总览和剖析List集合: Collection总览 List集合就这么简单【源码剖析】 原本我是打算继续将Collection下的Set集合的,结果看了源码发现:Set集合实际上就是HashMap来构建的! 所以,就先介绍Map集合、散列表和红黑树吧! 看这篇文章之前最好是有点数据结构的基础: Java实现单向链表 ...

weixin_33739523的博客 352

华为MetaERP在财务模块(GL/AP/AR/FA)及子账模块效率优化、月末关账加速、与外部系统对账方面,已形成一套**“并行+实时+智能化”**的完整技术方案

华为MetaERP推出"并行+实时+智能化"技术方案,显著提升财务模块效率:1)采用三级并行策略和内存计算,使子账模块单任务处理时间从142分钟降至9分钟;2)通过并行关账架构将月末关账时间从68小时压缩至7.2小时;3)运用AI智能对账提升效率50%,并支持异步流程和区块链审计。典型场景测试显示月结耗时下降89%,CPU利用率提升116%。方案建议分阶段实施,注意依赖分析、任务粒度设计和性能监控,避免过度并行。该方案已有效解决大型集团财务处理效率低、关账慢、对账难等痛点。

金牌架构师 562

哈希表、Java中HashMap

哈希算法,是一类算法; 哈希表(Hash Table)是一种数据结构; 哈希函数,是支撑哈希表的一类函数; Map是映射、地图的意思,在Java中Map表示一种把K映射到V的数据类型; HashMap是Java中用哈希数据结构实现的Map; 一、Hash算法 1. 是什么? 查词典 先来看英语翻译: hash 英 [hæʃ] 美 [hæʃ] n. 剁...

「有且仅有」 2万+

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

HashMap详解 Java [ 基础 ] ✅

HashMap是Java中一个强大且高效的集合类,用于快速查找和存储键值对。理解其工作原理和常用操作对于提高编程效率和解决复杂问题非常有帮助。

lenyan~的博客 2万+

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

HashMap相关面试题(哈希表、HashMap的实现原理、HashMap的put方法的具体流程、HashMap的扩容机制、HashMap的寻址算法)

HashMap相关面试题(哈希表、HashMap的实现原理、HashMap的put方法的具体流程、HashMap的扩容机制、HashMap的寻址算法)

聂可以的博客 2249

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

Java哈希表(HashTable,又称散列表)

哈希表是一种高效的数据结构,通过哈希函数将关键码映射到存储位置,实现O(1)时间复杂度的查找。文章详细介绍了哈希表的核心概念:哈希函数、哈希冲突(不同关键码映射到同一位置)、负载因子(元素个数/表长度,Java限制为0.75)及其调节方法。重点分析了两种解决冲突的方案:开放定址法(线性探测和二次探测)和链地址法(数组+链表)。文章还提供了哈希表的Java实现代码,包括插入、扩容、查找等操作,并讨论了性能分析和与Java集合类的关系。最后通过多个实际案例(如统计词频、找单身狗、复制链表等)展示了哈希表的应用。

Y409001的博客 1371

hashmap是散列表吗_一篇文章教你读懂哈希表-HashMap

题图Pid=68670770在最近的学习过程中,发现身边很多朋友对哈希表的原理和应用场景不甚了解,处于会用但不知道什么时候该用的状态,所以我找出了刚学习Java时写的HashMap实现,并以此为基础拓展关于哈希表的实现原理。什么是哈希表?散列表(Hash table,也叫哈希表),是根据关键码值(Key value)而直接进行访问的数据结构。也就是说,它通过把关键码值映射到表中一个位置来访问记录,...

weixin_28331555的博客 374

哈希表(HashMap、HashSet)

是个存储结构:可以让我们一次从表中直接拿到想要的元素,时间复杂度为O(1)为什么能实现O(1):通过哈希(散列)方法,使元素的存储位置和它的关键码之间建立一一映射的关系如果想要存取元素,都是利用哈希(散列)方法 + 关键码,从而计算出index位置,然后进行操作(怎么放的就怎么给它取出来哈希函数示例:此时写着容量是1000,但实际上是2次幂数,容量为1024。

wuweixiaoyue的博客 4145

[Java数据结构与算法] 哈希表(Hash Table)

首先对关键码集合用散列函数计算散列地址,具有相同地址的关键码归于同一子集合,每一个子集合称为一个桶,各个桶中的元素通过一个单链表链接起来,各链表的头结点存储在哈希表中。使用哈希桶能够有效解决数据存放的冲突问题,但是如果冲突严重,估计小集合的效率也会不尽人意,此时可以对小集合进行转化,如每一个桶的底层是一个哈希表 / 搜索树。虽然哈希表一直在和冲突做斗争,但在实际使用过程中,我们认为哈希表的冲突率是不高的,冲突个数是可控的。由于哈希表底层的空间大小往往是小于所要存储的数据的容量大小的,因此,

REGARD712的博客 1213

Java基础-HashMap集合

Map集合接口Map接口的常用方法2.Map集合的遍历第一种方式:获取所有的key,通过遍历key,来遍历value3.哈希表数据结构1.hashMap集合底层使哈希表/散列表的数据结构2.HashMap使一个怎样的数据结构呢?3.HashMap集合底层的源代码4.最主要掌握的是map.put(k,v);v=map.get(k);的原理5.HashMap的key部分6.哈希表HashMap使用不当时无法发挥其性能。7.重点:放在HashMap集合key部分的元素,以及放在HashSet集合中的元素,需要同时

Java硬件工程师的博客 3417

散列表(哈希表)

一. 简介 散列表也叫哈希表,是存储Key-Value映射的集合。通过哈希函数实现Key和数组下标的转换,通过开放寻址法和链表法解决哈希冲突,且读写操作时间复杂度接近O(1)。 二. 原理 哈希函数 散列表是基于数组的,通过哈希函数把Key和数组的下标进行转换。 哈希函数的实现方式有很多种,以HashMap中的哈希函数为例:每个对象都有属于自己的hashcode(唯一性),而hashco...

qq_44837912的博客 706

散列表(上)

散列思想 散列表就是我们平常说的哈希表,英文名叫"Hash Table",其基础依据就是: 散列表用的是数组支持按照下标随机访问数据的特性,所以散列表其实就是数组的一种扩展,由数组演化而来。可以说,如果没有数组,就没有散列表。 这里还是直接使用老师的例子来说事吧.中间添加自己的思想就行了.自己想例子又得半天,而且我们的目标也不是想一个好例子,而是真正理解并掌握知识.对吧? 用一个例子来解释一下。...

Tattoo的博客 1755

对于Java散列表的探究

对于HashMap的部分源码解读

weixin_64448174的博客 1229

哈希表、散列表

1.基本介绍 可能你听过散列表,散列函数,它们跟哈希表,哈希函数是一个概念。接下来以"哈希"来作梳理。 在介绍哈希表的时候,先来比较一下数组和链表的优缺点: 数组:寻址容易,但插入和删除元素比较麻烦; 链表:插入和删除元素容易,但寻址比较麻烦。 那么有没有一种数据结构是既能结合这两种的优点同时也能避免这两种数据结构所带来的缺点呢? 哈希表就是这样的数据结构: 哈希表的底层实际上是基于数组来存储的,当插入键值对时,并不是直接插入该数组中,而是通过对键进行Hash运算得到Hash值,然后和数组容量取模,得到

Deronn的博客 6235

转-散列表(哈希表)

散列表(哈希表) 散列表(Hash table,也叫哈希表),是根据关键码值(Key value)而直接进行访问的数据结构。也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。这个映射函数叫做散列函数,存放记录的数组叫做散列表。 给定表M,存在函数f(key),对任意给定的关键字值key,代入函数后若能得到包含该关键字的记录在表中的地址,则称表M为哈希(Hash)表,函数f(...

IT技术讨论 442
上一篇: 数据结构(9)-优先队列
下一篇: LeetCode(7)-树:DFS/BFS类问题
BoringRong
BoringRong 领域专家: 后端开发技术领域 领域专家: 后端开发技术领域
博客等级 码龄9年 2万+粉丝 386原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

BoringRong

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值